diff options
111 files changed, 8650 insertions, 1019 deletions
@@ -23,7 +23,7 @@ require ( codeberg.org/gruf/go-kv/v2 v2.0.7 codeberg.org/gruf/go-list v0.0.0-20240425093752-494db03d641f codeberg.org/gruf/go-mempool v0.0.0-20251003110531-b54adae66253 - codeberg.org/gruf/go-mmap v0.0.0-20251105140602-5f31e9314dbf + codeberg.org/gruf/go-mmap v0.0.0-20251105200114-34f58283863a codeberg.org/gruf/go-mutexes v1.5.8 codeberg.org/gruf/go-runners v1.7.0 codeberg.org/gruf/go-sched v1.3.0 @@ -49,9 +49,9 @@ require ( github.com/k3a/html2text v1.2.1 github.com/microcosm-cc/bluemonday v1.0.27 github.com/miekg/dns v1.1.68 - github.com/minio/minio-go/v7 v7.0.95 + github.com/minio/minio-go/v7 v7.0.97 github.com/mitchellh/mapstructure v1.5.0 - github.com/ncruces/go-sqlite3 v0.29.1 + github.com/ncruces/go-sqlite3 v0.30.0 github.com/oklog/ulid v1.3.1 github.com/pquerna/otp v1.5.0 github.com/rivo/uniseg v0.4.7 @@ -60,7 +60,7 @@ require ( github.com/spf13/pflag v1.0.10 github.com/spf13/viper v1.21.0 github.com/stretchr/testify v1.11.1 - github.com/tdewolff/minify/v2 v2.24.5 + github.com/tdewolff/minify/v2 v2.24.6 github.com/temoto/robotstxt v1.1.2 github.com/tetratelabs/wazero v1.9.0 github.com/tomnomnom/linkheader v0.0.0-20250811210735-e5fe3b51442e @@ -165,12 +165,13 @@ require ( github.com/json-iterator/go v1.1.12 // indirect github.com/klauspost/compress v1.18.0 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect + github.com/klauspost/crc32 v1.3.0 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect github.com/leodido/go-urn v1.4.0 // indirect github.com/mailru/easyjson v0.9.0 // indirect github.com/mattn/go-isatty v0.0.20 // indirect - github.com/minio/crc64nvme v1.0.2 // indirect + github.com/minio/crc64nvme v1.1.0 // indirect github.com/minio/md5-simd v1.1.2 // indirect github.com/mitchellh/copystructure v1.2.0 // indirect github.com/mitchellh/reflectwalk v1.0.2 // indirect @@ -199,7 +200,7 @@ require ( github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect github.com/spf13/afero v1.15.0 // indirect github.com/subosito/gotenv v1.6.0 // indirect - github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a // indirect + github.com/tdewolff/parse/v2 v2.8.5 // indirect github.com/tinylib/msgp v1.3.0 // indirect github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect github.com/toqueteos/webbrowser v1.2.1 // indirect @@ -44,8 +44,8 @@ codeberg.org/gruf/go-maps v1.0.4 h1:K+Ww4vvR3TZqm5jqrKVirmguZwa3v1VUvmig2SE8uxY= codeberg.org/gruf/go-maps v1.0.4/go.mod h1:ASX7osM7kFwt5O8GfGflcFjrwYGD8eIuRLl/oMjhEi8= codeberg.org/gruf/go-mempool v0.0.0-20251003110531-b54adae66253 h1:qPAY72xCWlySVROSNZecfLGAyeV/SiXmPmfhUU+o3Xw= codeberg.org/gruf/go-mempool v0.0.0-20251003110531-b54adae66253/go.mod h1:761koiXmqfgzvu5mez2Rk7YlwWilpqJ/zv5hIA6NoNI= -codeberg.org/gruf/go-mmap v0.0.0-20251105140602-5f31e9314dbf h1:WaQskbb8Rnp2CfpZ2pBhbmnnJ+Cxe0xvTSDE8fgdcfM= -codeberg.org/gruf/go-mmap v0.0.0-20251105140602-5f31e9314dbf/go.mod h1:kaHx5xHuLNf13iALbHiFpXmLeO33Ll/aW3mGkW8sI40= +codeberg.org/gruf/go-mmap v0.0.0-20251105200114-34f58283863a h1:b0SZOKBohFBiGDiMBAM7vwHZxwQ6wpL4uaajqtoke+c= +codeberg.org/gruf/go-mmap v0.0.0-20251105200114-34f58283863a/go.mod h1:kaHx5xHuLNf13iALbHiFpXmLeO33Ll/aW3mGkW8sI40= codeberg.org/gruf/go-mutexes v1.5.8 h1:HRGnvT4COb3jX9xdeoSUUbjPgmk5kXPuDfld9ksUJKA= codeberg.org/gruf/go-mutexes v1.5.8/go.mod h1:21sy/hWH8dDQBk7ocsxqo2GNpWiIir+e82RG3hjnN20= codeberg.org/gruf/go-runners v1.7.0 h1:Z+8Qne4H9nAdZZbA4cij0PWhhJxtigUGA4Mp7griYes= @@ -290,6 +290,8 @@ github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYW github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM= +github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -308,12 +310,12 @@ github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwX github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA= github.com/miekg/dns v1.1.68 h1:jsSRkNozw7G/mnmXULynzMNIsgY2dHC8LO6U6Ij2JEA= github.com/miekg/dns v1.1.68/go.mod h1:fujopn7TB3Pu3JM69XaawiU0wqjpL9/8xGop5UrTPps= -github.com/minio/crc64nvme v1.0.2 h1:6uO1UxGAD+kwqWWp7mBFsi5gAse66C4NXO8cmcVculg= -github.com/minio/crc64nvme v1.0.2/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= +github.com/minio/crc64nvme v1.1.0 h1:e/tAguZ+4cw32D+IO/8GSf5UVr9y+3eJcxZI2WOO/7Q= +github.com/minio/crc64nvme v1.1.0/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= -github.com/minio/minio-go/v7 v7.0.95 h1:ywOUPg+PebTMTzn9VDsoFJy32ZuARN9zhB+K3IYEvYU= -github.com/minio/minio-go/v7 v7.0.95/go.mod h1:wOOX3uxS334vImCNRVyIDdXX9OsXDm89ToynKgqUKlo= +github.com/minio/minio-go/v7 v7.0.97 h1:lqhREPyfgHTB/ciX8k2r8k0D93WaFqxbJX36UZq5occ= +github.com/minio/minio-go/v7 v7.0.97/go.mod h1:re5VXuo0pwEtoNLsNuSr0RrLfT/MBtohwdaSmPPSRSk= github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= @@ -331,8 +333,8 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= -github.com/ncruces/go-sqlite3 v0.29.1 h1:NIi8AISWBToRHyoz01FXiTNvU147Tqdibgj2tFzJCqM= -github.com/ncruces/go-sqlite3 v0.29.1/go.mod h1:PpccBNNhvjwUOwDQEn2gXQPFPTWdlromj0+fSkd5KSg= +github.com/ncruces/go-sqlite3 v0.30.0 h1:EcoP5wtm8lRfRGQmOI782t/matUvzpqI3om9rTDngQ8= +github.com/ncruces/go-sqlite3 v0.30.0/go.mod h1:6mcRKUuA9qvAo7PcQU+wwcT2j/qGimg1qXO/pmj8Ryk= github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M= @@ -418,10 +420,10 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= -github.com/tdewolff/minify/v2 v2.24.5 h1:ytxthX3xSxrK3Xx5B38flg5moCKs/dB8VwiD/RzJViU= -github.com/tdewolff/minify/v2 v2.24.5/go.mod h1:q09KtNnVai7TyEzGEZeWPAnK+c8Z+NI8prCXZW652bo= -github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a h1:Rmq+utdraciok/97XHRweYdsAo/M4LOswpCboo3yvN4= -github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a/go.mod h1:Hwlni2tiVNKyzR1o6nUs4FOF07URA+JLBLd6dlIXYqo= +github.com/tdewolff/minify/v2 v2.24.6 h1:GdScQWO9fJcMsR93SFWFvD3q3b4W4Uhf81VBYAiK8qk= +github.com/tdewolff/minify/v2 v2.24.6/go.mod h1:0Ukj0CRpo/sW/nd8uZ4ccXaV1rEVIWA3dj8U7+Shhfw= +github.com/tdewolff/parse/v2 v2.8.5 h1:ZmBiA/8Do5Rpk7bDye0jbbDUpXXbCdc3iah4VeUvwYU= +github.com/tdewolff/parse/v2 v2.8.5/go.mod h1:Hwlni2tiVNKyzR1o6nUs4FOF07URA+JLBLd6dlIXYqo= github.com/tdewolff/test v1.0.11 h1:FdLbwQVHxqG16SlkGveC0JVyrJN62COWTRyUFzfbtBE= github.com/tdewolff/test v1.0.11/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8= github.com/temoto/robotstxt v1.1.2 h1:W2pOjSJ6SWvldyEuiFXNxz3xZ8aiWX5LbfDiOFd7Fxg= diff --git a/vendor/codeberg.org/gruf/go-mmap/copy_fill_stat.sh b/vendor/codeberg.org/gruf/go-mmap/copy_fill_stat.sh new file mode 100644 index 000000000..ab67bfae9 --- /dev/null +++ b/vendor/codeberg.org/gruf/go-mmap/copy_fill_stat.sh @@ -0,0 +1,14 @@ +#!/bin/bash +set -e + +for file in "$(go env GOROOT)"/src/os/stat_{linux,netbsd,openbsd,freebsd}.go; do + cp "$file" . + name="$(basename "$file")" + sed -i "./${name}" -E -e 's|package os|package mmap|' \ + -e 's|internal/filepathlite|path|' \ + -e 's|filepathlite|path|g' \ + -e 's| FileMode| os.FileMode|g' \ + -e 's| Mode| os.Mode|g' \ + -e 's| FileInfo| os.FileInfo|g' + gofmt -w "./${name}"; goimports -w "./${name}" +done diff --git a/vendor/codeberg.org/gruf/go-mmap/fs.go b/vendor/codeberg.org/gruf/go-mmap/fs.go index 8c47d84b0..743523259 100644 --- a/vendor/codeberg.org/gruf/go-mmap/fs.go +++ b/vendor/codeberg.org/gruf/go-mmap/fs.go @@ -2,23 +2,24 @@ package mmap import ( "io/fs" - "path" "syscall" "time" ) type fileStat struct { - syscall.Stat_t - name string - mode fs.FileMode + name string + size int64 + mode fs.FileMode + modTime time.Time + sys syscall.Stat_t } -func (s *fileStat) Name() string { return s.name } -func (s *fileStat) IsDir() bool { return s.mode.IsDir() } -func (s *fileStat) Mode() fs.FileMode { return s.mode } -func (s *fileStat) Size() int64 { return s.Stat_t.Size } -func (s *fileStat) ModTime() time.Time { return time.Unix(s.Stat_t.Mtim.Unix()) } -func (s *fileStat) Sys() any { return &s.Stat_t } +func (fs *fileStat) Name() string { return fs.name } +func (fs *fileStat) Size() int64 { return fs.size } +func (fs *fileStat) IsDir() bool { return fs.mode.IsDir() } +func (fs *fileStat) Mode() fs.FileMode { return fs.mode } +func (fs *fileStat) ModTime() time.Time { return fs.modTime } +func (fs *fileStat) Sys() any { return &fs.sys } // open is a simple wrapper around syscall.Open(). func open(filepath string, mode int, perm uint32) (fd int, err error) { @@ -33,38 +34,12 @@ func open(filepath string, mode int, perm uint32) (fd int, err error) { func stat(filepath string) (*fileStat, error) { var stat fileStat err := retryOnEINTR(func() error { - return syscall.Stat(filepath, &stat.Stat_t) + return syscall.Stat(filepath, &stat.sys) }) if err != nil { return nil, err } - stat.name = path.Base(filepath) - stat.mode = fs.FileMode(stat.Stat_t.Mode & 0777) - switch stat.Stat_t.Mode & syscall.S_IFMT { - case syscall.S_IFBLK: - stat.mode |= fs.ModeDevice - case syscall.S_IFCHR: - stat.mode |= fs.ModeDevice | fs.ModeCharDevice - case syscall.S_IFDIR: - stat.mode |= fs.ModeDir - case syscall.S_IFIFO: - stat.mode |= fs.ModeNamedPipe - case syscall.S_IFLNK: - stat.mode |= fs.ModeSymlink - case syscall.S_IFREG: - // nothing to do - case syscall.S_IFSOCK: - stat.mode |= fs.ModeSocket - } - if stat.Stat_t.Mode&syscall.S_ISGID != 0 { - stat.mode |= fs.ModeSetgid - } - if stat.Stat_t.Mode&syscall.S_ISUID != 0 { - stat.mode |= fs.ModeSetuid - } - if stat.Stat_t.Mode&syscall.S_ISVTX != 0 { - stat.mode |= fs.ModeSticky - } + fillFileStatFromSys(&stat, filepath) return &stat, nil } diff --git a/vendor/codeberg.org/gruf/go-mmap/stat_freebsd.go b/vendor/codeberg.org/gruf/go-mmap/stat_freebsd.go new file mode 100644 index 000000000..271ca30e8 --- /dev/null +++ b/vendor/codeberg.org/gruf/go-mmap/stat_freebsd.go @@ -0,0 +1,49 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mmap + +import ( + "os" + "path" + "syscall" + "time" +) + +func fillFileStatFromSys(fs *fileStat, name string) { + fs.name = path.Base(name) + fs.size = fs.sys.Size + fs.modTime = time.Unix(fs.sys.Mtimespec.Unix()) + fs.mode = os.FileMode(fs.sys.Mode & 0777) + switch fs.sys.Mode & syscall.S_IFMT { + case syscall.S_IFBLK: + fs.mode |= os.ModeDevice + case syscall.S_IFCHR: + fs.mode |= os.ModeDevice | os.ModeCharDevice + case syscall.S_IFDIR: + fs.mode |= os.ModeDir + case syscall.S_IFIFO: + fs.mode |= os.ModeNamedPipe + case syscall.S_IFLNK: + fs.mode |= os.ModeSymlink + case syscall.S_IFREG: + // nothing to do + case syscall.S_IFSOCK: + fs.mode |= os.ModeSocket + } + if fs.sys.Mode&syscall.S_ISGID != 0 { + fs.mode |= os.ModeSetgid + } + if fs.sys.Mode&syscall.S_ISUID != 0 { + fs.mode |= os.ModeSetuid + } + if fs.sys.Mode&syscall.S_ISVTX != 0 { + fs.mode |= os.ModeSticky + } +} + +// For testing. +func atime(fi os.FileInfo) time.Time { + return time.Unix(fi.Sys().(*syscall.Stat_t).Atimespec.Unix()) +} diff --git a/vendor/codeberg.org/gruf/go-mmap/stat_linux.go b/vendor/codeberg.org/gruf/go-mmap/stat_linux.go new file mode 100644 index 000000000..4f4ebc164 --- /dev/null +++ b/vendor/codeberg.org/gruf/go-mmap/stat_linux.go @@ -0,0 +1,49 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mmap + +import ( + "os" + "path" + "syscall" + "time" +) + +func fillFileStatFromSys(fs *fileStat, name string) { + fs.name = path.Base(name) + fs.size = fs.sys.Size + fs.modTime = time.Unix(fs.sys.Mtim.Unix()) + fs.mode = os.FileMode(fs.sys.Mode & 0777) + switch fs.sys.Mode & syscall.S_IFMT { + case syscall.S_IFBLK: + fs.mode |= os.ModeDevice + case syscall.S_IFCHR: + fs.mode |= os.ModeDevice | os.ModeCharDevice + case syscall.S_IFDIR: + fs.mode |= os.ModeDir + case syscall.S_IFIFO: + fs.mode |= os.ModeNamedPipe + case syscall.S_IFLNK: + fs.mode |= os.ModeSymlink + case syscall.S_IFREG: + // nothing to do + case syscall.S_IFSOCK: + fs.mode |= os.ModeSocket + } + if fs.sys.Mode&syscall.S_ISGID != 0 { + fs.mode |= os.ModeSetgid + } + if fs.sys.Mode&syscall.S_ISUID != 0 { + fs.mode |= os.ModeSetuid + } + if fs.sys.Mode&syscall.S_ISVTX != 0 { + fs.mode |= os.ModeSticky + } +} + +// For testing. +func atime(fi os.FileInfo) time.Time { + return time.Unix(fi.Sys().(*syscall.Stat_t).Atim.Unix()) +} diff --git a/vendor/codeberg.org/gruf/go-mmap/stat_netbsd.go b/vendor/codeberg.org/gruf/go-mmap/stat_netbsd.go new file mode 100644 index 000000000..271ca30e8 --- /dev/null +++ b/vendor/codeberg.org/gruf/go-mmap/stat_netbsd.go @@ -0,0 +1,49 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mmap + +import ( + "os" + "path" + "syscall" + "time" +) + +func fillFileStatFromSys(fs *fileStat, name string) { + fs.name = path.Base(name) + fs.size = fs.sys.Size + fs.modTime = time.Unix(fs.sys.Mtimespec.Unix()) + fs.mode = os.FileMode(fs.sys.Mode & 0777) + switch fs.sys.Mode & syscall.S_IFMT { + case syscall.S_IFBLK: + fs.mode |= os.ModeDevice + case syscall.S_IFCHR: + fs.mode |= os.ModeDevice | os.ModeCharDevice + case syscall.S_IFDIR: + fs.mode |= os.ModeDir + case syscall.S_IFIFO: + fs.mode |= os.ModeNamedPipe + case syscall.S_IFLNK: + fs.mode |= os.ModeSymlink + case syscall.S_IFREG: + // nothing to do + case syscall.S_IFSOCK: + fs.mode |= os.ModeSocket + } + if fs.sys.Mode&syscall.S_ISGID != 0 { + fs.mode |= os.ModeSetgid + } + if fs.sys.Mode&syscall.S_ISUID != 0 { + fs.mode |= os.ModeSetuid + } + if fs.sys.Mode&syscall.S_ISVTX != 0 { + fs.mode |= os.ModeSticky + } +} + +// For testing. +func atime(fi os.FileInfo) time.Time { + return time.Unix(fi.Sys().(*syscall.Stat_t).Atimespec.Unix()) +} diff --git a/vendor/codeberg.org/gruf/go-mmap/stat_openbsd.go b/vendor/codeberg.org/gruf/go-mmap/stat_openbsd.go new file mode 100644 index 000000000..4f4ebc164 --- /dev/null +++ b/vendor/codeberg.org/gruf/go-mmap/stat_openbsd.go @@ -0,0 +1,49 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mmap + +import ( + "os" + "path" + "syscall" + "time" +) + +func fillFileStatFromSys(fs *fileStat, name string) { + fs.name = path.Base(name) + fs.size = fs.sys.Size + fs.modTime = time.Unix(fs.sys.Mtim.Unix()) + fs.mode = os.FileMode(fs.sys.Mode & 0777) + switch fs.sys.Mode & syscall.S_IFMT { + case syscall.S_IFBLK: + fs.mode |= os.ModeDevice + case syscall.S_IFCHR: + fs.mode |= os.ModeDevice | os.ModeCharDevice + case syscall.S_IFDIR: + fs.mode |= os.ModeDir + case syscall.S_IFIFO: + fs.mode |= os.ModeNamedPipe + case syscall.S_IFLNK: + fs.mode |= os.ModeSymlink + case syscall.S_IFREG: + // nothing to do + case syscall.S_IFSOCK: + fs.mode |= os.ModeSocket + } + if fs.sys.Mode&syscall.S_ISGID != 0 { + fs.mode |= os.ModeSetgid + } + if fs.sys.Mode&syscall.S_ISUID != 0 { + fs.mode |= os.ModeSetuid + } + if fs.sys.Mode&syscall.S_ISVTX != 0 { + fs.mode |= os.ModeSticky + } +} + +// For testing. +func atime(fi os.FileInfo) time.Time { + return time.Unix(fi.Sys().(*syscall.Stat_t).Atim.Unix()) +} diff --git a/vendor/github.com/klauspost/crc32/.gitignore b/vendor/github.com/klauspost/crc32/.gitignore new file mode 100644 index 000000000..daf913b1b --- /dev/null +++ b/vendor/github.com/klauspost/crc32/.gitignore @@ -0,0 +1,24 @@ +# Compiled Object files, Static and Dynamic libs (Shared Objects) +*.o +*.a +*.so + +# Folders +_obj +_test + +# Architecture specific extensions/prefixes +*.[568vq] +[568vq].out + +*.cgo1.go +*.cgo2.c +_cgo_defun.c +_cgo_gotypes.go +_cgo_export.* + +_testmain.go + +*.exe +*.test +*.prof diff --git a/vendor/github.com/klauspost/crc32/LICENSE b/vendor/github.com/klauspost/crc32/LICENSE new file mode 100644 index 000000000..744875676 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2012 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/klauspost/crc32/README.md b/vendor/github.com/klauspost/crc32/README.md new file mode 100644 index 000000000..febeba5eb --- /dev/null +++ b/vendor/github.com/klauspost/crc32/README.md @@ -0,0 +1,42 @@ +# 2025 revival + +For IEEE checksums AVX512 can be used to speed up CRC32 checksums by approximately 2x. + +Castagnoli checksums (CRC32C) can also be computer with AVX512, +but the performance gain is not as significant enough for the downsides of using it at this point. + +# crc32 + +This package is a drop-in replacement for the standard library `hash/crc32` package, +that features AVX 512 optimizations on x64 platforms, for a 2x speedup for IEEE CRC32 checksums. + +# usage + +Install using `go get github.com/klauspost/crc32`. This library is based on Go 1.24 + +Replace `import "hash/crc32"` with `import "github.com/klauspost/crc32"` and you are good to go. + +# changes +* 2025: Revived and updated to Go 1.24, with AVX 512 optimizations. + +# performance + +AVX512 are enabled above 1KB input size. This rather high limit is due to AVX512 may be slower to ramp up than +the regular SSE4 implementation for smaller inputs. This is not reflected in the benchmarks below. + +| Benchmark | Old MB/s | New MB/s | Speedup | +|-----------------------------------------------|----------|----------|---------| +| BenchmarkCRC32/poly=IEEE/size=512/align=0-32 | 17996.39 | 17969.94 | 1.00x | +| BenchmarkCRC32/poly=IEEE/size=512/align=1-32 | 18021.48 | 17945.55 | 1.00x | +| BenchmarkCRC32/poly=IEEE/size=1kB/align=0-32 | 19921.70 | 45613.77 | 2.29x | +| BenchmarkCRC32/poly=IEEE/size=1kB/align=1-32 | 19946.60 | 46819.09 | 2.35x | +| BenchmarkCRC32/poly=IEEE/size=4kB/align=0-32 | 21538.65 | 48600.93 | 2.26x | +| BenchmarkCRC32/poly=IEEE/size=4kB/align=1-32 | 21449.20 | 48477.84 | 2.26x | +| BenchmarkCRC32/poly=IEEE/size=32kB/align=0-32 | 21785.49 | 46013.10 | 2.11x | +| BenchmarkCRC32/poly=IEEE/size=32kB/align=1-32 | 21946.47 | 45954.10 | 2.09x | + +cpu: AMD Ryzen 9 9950X 16-Core Processor + +# license + +Standard Go license. See [LICENSE](LICENSE) for details. diff --git a/vendor/github.com/klauspost/crc32/crc32.go b/vendor/github.com/klauspost/crc32/crc32.go new file mode 100644 index 000000000..1de0bb3a4 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32.go @@ -0,0 +1,253 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package crc32 implements the 32-bit cyclic redundancy check, or CRC-32, +// checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for +// information. +// +// Polynomials are represented in LSB-first form also known as reversed representation. +// +// See https://en.wikipedia.org/wiki/Mathematics_of_cyclic_redundancy_checks#Reversed_representations_and_reciprocal_polynomials +// for information. +package crc32 + +import ( + "encoding/binary" + "errors" + "hash" + "sync" + "sync/atomic" +) + +// The size of a CRC-32 checksum in bytes. +const Size = 4 + +// Predefined polynomials. +const ( + // IEEE is by far and away the most common CRC-32 polynomial. + // Used by ethernet (IEEE 802.3), v.42, fddi, gzip, zip, png, ... + IEEE = 0xedb88320 + + // Castagnoli's polynomial, used in iSCSI. + // Has better error detection characteristics than IEEE. + // https://dx.doi.org/10.1109/26.231911 + Castagnoli = 0x82f63b78 + + // Koopman's polynomial. + // Also has better error detection characteristics than IEEE. + // https://dx.doi.org/10.1109/DSN.2002.1028931 + Koopman = 0xeb31d82e +) + +// Table is a 256-word table representing the polynomial for efficient processing. +type Table [256]uint32 + +// This file makes use of functions implemented in architecture-specific files. +// The interface that they implement is as follows: +// +// // archAvailableIEEE reports whether an architecture-specific CRC32-IEEE +// // algorithm is available. +// archAvailableIEEE() bool +// +// // archInitIEEE initializes the architecture-specific CRC3-IEEE algorithm. +// // It can only be called if archAvailableIEEE() returns true. +// archInitIEEE() +// +// // archUpdateIEEE updates the given CRC32-IEEE. It can only be called if +// // archInitIEEE() was previously called. +// archUpdateIEEE(crc uint32, p []byte) uint32 +// +// // archAvailableCastagnoli reports whether an architecture-specific +// // CRC32-C algorithm is available. +// archAvailableCastagnoli() bool +// +// // archInitCastagnoli initializes the architecture-specific CRC32-C +// // algorithm. It can only be called if archAvailableCastagnoli() returns +// // true. +// archInitCastagnoli() +// +// // archUpdateCastagnoli updates the given CRC32-C. It can only be called +// // if archInitCastagnoli() was previously called. +// archUpdateCastagnoli(crc uint32, p []byte) uint32 + +// castagnoliTable points to a lazily initialized Table for the Castagnoli +// polynomial. MakeTable will always return this value when asked to make a +// Castagnoli table so we can compare against it to find when the caller is +// using this polynomial. +var castagnoliTable *Table +var castagnoliTable8 *slicing8Table +var updateCastagnoli func(crc uint32, p []byte) uint32 +var haveCastagnoli atomic.Bool + +var castagnoliInitOnce = sync.OnceFunc(func() { + castagnoliTable = simpleMakeTable(Castagnoli) + + if archAvailableCastagnoli() { + archInitCastagnoli() + updateCastagnoli = archUpdateCastagnoli + } else { + // Initialize the slicing-by-8 table. + castagnoliTable8 = slicingMakeTable(Castagnoli) + updateCastagnoli = func(crc uint32, p []byte) uint32 { + return slicingUpdate(crc, castagnoliTable8, p) + } + } + + haveCastagnoli.Store(true) +}) + +// IEEETable is the table for the [IEEE] polynomial. +var IEEETable = simpleMakeTable(IEEE) + +// ieeeTable8 is the slicing8Table for IEEE +var ieeeTable8 *slicing8Table +var updateIEEE func(crc uint32, p []byte) uint32 + +var ieeeInitOnce = sync.OnceFunc(func() { + if archAvailableIEEE() { + archInitIEEE() + updateIEEE = archUpdateIEEE + } else { + // Initialize the slicing-by-8 table. + ieeeTable8 = slicingMakeTable(IEEE) + updateIEEE = func(crc uint32, p []byte) uint32 { + return slicingUpdate(crc, ieeeTable8, p) + } + } +}) + +// MakeTable returns a [Table] constructed from the specified polynomial. +// The contents of this [Table] must not be modified. +func MakeTable(poly uint32) *Table { + switch poly { + case IEEE: + ieeeInitOnce() + return IEEETable + case Castagnoli: + castagnoliInitOnce() + return castagnoliTable + default: + return simpleMakeTable(poly) + } +} + +// digest represents the partial evaluation of a checksum. +type digest struct { + crc uint32 + tab *Table +} + +// New creates a new [hash.Hash32] computing the CRC-32 checksum using the +// polynomial represented by the [Table]. Its Sum method will lay the +// value out in big-endian byte order. The returned Hash32 also +// implements [encoding.BinaryMarshaler] and [encoding.BinaryUnmarshaler] to +// marshal and unmarshal the internal state of the hash. +func New(tab *Table) hash.Hash32 { + if tab == IEEETable { + ieeeInitOnce() + } + return &digest{0, tab} +} + +// NewIEEE creates a new [hash.Hash32] computing the CRC-32 checksum using +// the [IEEE] polynomial. Its Sum method will lay the value out in +// big-endian byte order. The returned Hash32 also implements +// [encoding.BinaryMarshaler] and [encoding.BinaryUnmarshaler] to marshal +// and unmarshal the internal state of the hash. +func NewIEEE() hash.Hash32 { return New(IEEETable) } + +func (d *digest) Size() int { return Size } + +func (d *digest) BlockSize() int { return 1 } + +func (d *digest) Reset() { d.crc = 0 } + +const ( + magic = "crc\x01" + marshaledSize = len(magic) + 4 + 4 +) + +func (d *digest) AppendBinary(b []byte) ([]byte, error) { + b = append(b, magic...) + b = binary.BigEndian.AppendUint32(b, tableSum(d.tab)) + b = binary.BigEndian.AppendUint32(b, d.crc) + return b, nil +} + +func (d *digest) MarshalBinary() ([]byte, error) { + return d.AppendBinary(make([]byte, 0, marshaledSize)) + +} + +func (d *digest) UnmarshalBinary(b []byte) error { + if len(b) < len(magic) || string(b[:len(magic)]) != magic { + return errors.New("hash/crc32: invalid hash state identifier") + } + if len(b) != marshaledSize { + return errors.New("hash/crc32: invalid hash state size") + } + if tableSum(d.tab) != binary.BigEndian.Uint32(b[4:]) { + return errors.New("hash/crc32: tables do not match") + } + d.crc = binary.BigEndian.Uint32(b[8:]) + return nil +} + +func update(crc uint32, tab *Table, p []byte, checkInitIEEE bool) uint32 { + switch { + case haveCastagnoli.Load() && tab == castagnoliTable: + return updateCastagnoli(crc, p) + case tab == IEEETable: + if checkInitIEEE { + ieeeInitOnce() + } + return updateIEEE(crc, p) + default: + return simpleUpdate(crc, tab, p) + } +} + +// Update returns the result of adding the bytes in p to the crc. +func Update(crc uint32, tab *Table, p []byte) uint32 { + // Unfortunately, because IEEETable is exported, IEEE may be used without a + // call to MakeTable. We have to make sure it gets initialized in that case. + return update(crc, tab, p, true) +} + +func (d *digest) Write(p []byte) (n int, err error) { + // We only create digest objects through New() which takes care of + // initialization in this case. + d.crc = update(d.crc, d.tab, p, false) + return len(p), nil +} + +func (d *digest) Sum32() uint32 { return d.crc } + +func (d *digest) Sum(in []byte) []byte { + s := d.Sum32() + return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s)) +} + +// Checksum returns the CRC-32 checksum of data +// using the polynomial represented by the [Table]. +func Checksum(data []byte, tab *Table) uint32 { return Update(0, tab, data) } + +// ChecksumIEEE returns the CRC-32 checksum of data +// using the [IEEE] polynomial. +func ChecksumIEEE(data []byte) uint32 { + ieeeInitOnce() + return updateIEEE(0, data) +} + +// tableSum returns the IEEE checksum of table t. +func tableSum(t *Table) uint32 { + var a [1024]byte + b := a[:0] + if t != nil { + for _, x := range t { + b = binary.BigEndian.AppendUint32(b, x) + } + } + return ChecksumIEEE(b) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_amd64.go b/vendor/github.com/klauspost/crc32/crc32_amd64.go new file mode 100644 index 000000000..c6d30b25c --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_amd64.go @@ -0,0 +1,253 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// AMD64-specific hardware-assisted CRC32 algorithms. See crc32.go for a +// description of the interface that each architecture-specific file +// implements. + +package crc32 + +import ( + "unsafe" + + "golang.org/x/sys/cpu" +) + +// This file contains the code to call the SSE 4.2 version of the Castagnoli +// and IEEE CRC. + +// castagnoliSSE42 is defined in crc32_amd64.s and uses the SSE 4.2 CRC32 +// instruction. +// +//go:noescape +func castagnoliSSE42(crc uint32, p []byte) uint32 + +// castagnoliSSE42Triple is defined in crc32_amd64.s and uses the SSE 4.2 CRC32 +// instruction. +// +//go:noescape +func castagnoliSSE42Triple( + crcA, crcB, crcC uint32, + a, b, c []byte, + rounds uint32, +) (retA uint32, retB uint32, retC uint32) + +// ieeeCLMUL is defined in crc_amd64.s and uses the PCLMULQDQ +// instruction as well as SSE 4.1. +// +//go:noescape +func ieeeCLMUL(crc uint32, p []byte) uint32 + +// castagnoliCLMULAvx512 is defined in crc_amd64.s and uses the PCLMULQDQ +// instruction as well as SSE 4.1. +// +//go:noescape +func castagnoliCLMULAvx512(crc uint32, p []byte) uint32 + +// ieeeCLMUL is defined in crc_amd64.s and uses the PCLMULQDQ +// instruction as well as SSE 4.1. +// +//go:noescape +func ieeeCLMULAvx512(crc uint32, p []byte) uint32 + +const castagnoliK1 = 168 +const castagnoliK2 = 1344 + +type sse42Table [4]Table + +var castagnoliSSE42TableK1 *sse42Table +var castagnoliSSE42TableK2 *sse42Table + +func archAvailableCastagnoli() bool { + return cpu.X86.HasSSE42 +} + +func archInitCastagnoli() { + if !cpu.X86.HasSSE42 { + panic("arch-specific Castagnoli not available") + } + castagnoliSSE42TableK1 = new(sse42Table) + castagnoliSSE42TableK2 = new(sse42Table) + // See description in updateCastagnoli. + // t[0][i] = CRC(i000, O) + // t[1][i] = CRC(0i00, O) + // t[2][i] = CRC(00i0, O) + // t[3][i] = CRC(000i, O) + // where O is a sequence of K zeros. + var tmp [castagnoliK2]byte + for b := 0; b < 4; b++ { + for i := 0; i < 256; i++ { + val := uint32(i) << uint32(b*8) + castagnoliSSE42TableK1[b][i] = castagnoliSSE42(val, tmp[:castagnoliK1]) + castagnoliSSE42TableK2[b][i] = castagnoliSSE42(val, tmp[:]) + } + } +} + +// castagnoliShift computes the CRC32-C of K1 or K2 zeroes (depending on the +// table given) with the given initial crc value. This corresponds to +// CRC(crc, O) in the description in updateCastagnoli. +func castagnoliShift(table *sse42Table, crc uint32) uint32 { + return table[3][crc>>24] ^ + table[2][(crc>>16)&0xFF] ^ + table[1][(crc>>8)&0xFF] ^ + table[0][crc&0xFF] +} + +func archUpdateCastagnoli(crc uint32, p []byte) uint32 { + if !cpu.X86.HasSSE42 { + panic("not available") + } + + // This method is inspired from the algorithm in Intel's white paper: + // "Fast CRC Computation for iSCSI Polynomial Using CRC32 Instruction" + // The same strategy of splitting the buffer in three is used but the + // combining calculation is different; the complete derivation is explained + // below. + // + // -- The basic idea -- + // + // The CRC32 instruction (available in SSE4.2) can process 8 bytes at a + // time. In recent Intel architectures the instruction takes 3 cycles; + // however the processor can pipeline up to three instructions if they + // don't depend on each other. + // + // Roughly this means that we can process three buffers in about the same + // time we can process one buffer. + // + // The idea is then to split the buffer in three, CRC the three pieces + // separately and then combine the results. + // + // Combining the results requires precomputed tables, so we must choose a + // fixed buffer length to optimize. The longer the length, the faster; but + // only buffers longer than this length will use the optimization. We choose + // two cutoffs and compute tables for both: + // - one around 512: 168*3=504 + // - one around 4KB: 1344*3=4032 + // + // -- The nitty gritty -- + // + // Let CRC(I, X) be the non-inverted CRC32-C of the sequence X (with + // initial non-inverted CRC I). This function has the following properties: + // (a) CRC(I, AB) = CRC(CRC(I, A), B) + // (b) CRC(I, A xor B) = CRC(I, A) xor CRC(0, B) + // + // Say we want to compute CRC(I, ABC) where A, B, C are three sequences of + // K bytes each, where K is a fixed constant. Let O be the sequence of K zero + // bytes. + // + // CRC(I, ABC) = CRC(I, ABO xor C) + // = CRC(I, ABO) xor CRC(0, C) + // = CRC(CRC(I, AB), O) xor CRC(0, C) + // = CRC(CRC(I, AO xor B), O) xor CRC(0, C) + // = CRC(CRC(I, AO) xor CRC(0, B), O) xor CRC(0, C) + // = CRC(CRC(CRC(I, A), O) xor CRC(0, B), O) xor CRC(0, C) + // + // The castagnoliSSE42Triple function can compute CRC(I, A), CRC(0, B), + // and CRC(0, C) efficiently. We just need to find a way to quickly compute + // CRC(uvwx, O) given a 4-byte initial value uvwx. We can precompute these + // values; since we can't have a 32-bit table, we break it up into four + // 8-bit tables: + // + // CRC(uvwx, O) = CRC(u000, O) xor + // CRC(0v00, O) xor + // CRC(00w0, O) xor + // CRC(000x, O) + // + // We can compute tables corresponding to the four terms for all 8-bit + // values. + + crc = ^crc + + // Disabled, since it is not significantly faster than the SSE 4.2 version, even on Zen 5. + if false && len(p) >= 2048 && cpu.X86.HasAVX512F && cpu.X86.HasAVX512VL && cpu.X86.HasAVX512VPCLMULQDQ && cpu.X86.HasPCLMULQDQ { + left := len(p) & 15 + do := len(p) - left + crc = castagnoliCLMULAvx512(crc, p[:do]) + return ^castagnoliSSE42(crc, p[do:]) + } + + // If a buffer is long enough to use the optimization, process the first few + // bytes to align the buffer to an 8 byte boundary (if necessary). + if len(p) >= castagnoliK1*3 { + delta := int(uintptr(unsafe.Pointer(&p[0])) & 7) + if delta != 0 { + delta = 8 - delta + crc = castagnoliSSE42(crc, p[:delta]) + p = p[delta:] + } + } + + // Process 3*K2 at a time. + for len(p) >= castagnoliK2*3 { + // Compute CRC(I, A), CRC(0, B), and CRC(0, C). + crcA, crcB, crcC := castagnoliSSE42Triple( + crc, 0, 0, + p, p[castagnoliK2:], p[castagnoliK2*2:], + castagnoliK2/24) + + // CRC(I, AB) = CRC(CRC(I, A), O) xor CRC(0, B) + crcAB := castagnoliShift(castagnoliSSE42TableK2, crcA) ^ crcB + // CRC(I, ABC) = CRC(CRC(I, AB), O) xor CRC(0, C) + crc = castagnoliShift(castagnoliSSE42TableK2, crcAB) ^ crcC + p = p[castagnoliK2*3:] + } + + // Process 3*K1 at a time. + for len(p) >= castagnoliK1*3 { + // Compute CRC(I, A), CRC(0, B), and CRC(0, C). + crcA, crcB, crcC := castagnoliSSE42Triple( + crc, 0, 0, + p, p[castagnoliK1:], p[castagnoliK1*2:], + castagnoliK1/24) + + // CRC(I, AB) = CRC(CRC(I, A), O) xor CRC(0, B) + crcAB := castagnoliShift(castagnoliSSE42TableK1, crcA) ^ crcB + // CRC(I, ABC) = CRC(CRC(I, AB), O) xor CRC(0, C) + crc = castagnoliShift(castagnoliSSE42TableK1, crcAB) ^ crcC + p = p[castagnoliK1*3:] + } + + // Use the simple implementation for what's left. + crc = castagnoliSSE42(crc, p) + return ^crc +} + +func archAvailableIEEE() bool { + return cpu.X86.HasPCLMULQDQ && cpu.X86.HasSSE41 +} + +var archIeeeTable8 *slicing8Table + +func archInitIEEE() { + if !cpu.X86.HasPCLMULQDQ || !cpu.X86.HasSSE41 { + panic("not available") + } + // We still use slicing-by-8 for small buffers. + archIeeeTable8 = slicingMakeTable(IEEE) +} + +func archUpdateIEEE(crc uint32, p []byte) uint32 { + if !cpu.X86.HasPCLMULQDQ || !cpu.X86.HasSSE41 { + panic("not available") + } + + if len(p) >= 64 { + if len(p) >= 1024 && cpu.X86.HasAVX512F && cpu.X86.HasAVX512VL && cpu.X86.HasAVX512VPCLMULQDQ && cpu.X86.HasPCLMULQDQ { + left := len(p) & 15 + do := len(p) - left + crc = ^ieeeCLMULAvx512(^crc, p[:do]) + p = p[do:] + } else { + left := len(p) & 15 + do := len(p) - left + crc = ^ieeeCLMUL(^crc, p[:do]) + p = p[do:] + } + } + if len(p) == 0 { + return crc + } + return slicingUpdate(crc, archIeeeTable8, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_amd64.s b/vendor/github.com/klauspost/crc32/crc32_amd64.s new file mode 100644 index 000000000..e2de3a5cb --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_amd64.s @@ -0,0 +1,527 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "textflag.h" + +// castagnoliSSE42 updates the (non-inverted) crc with the given buffer. +// +// func castagnoliSSE42(crc uint32, p []byte) uint32 +TEXT ·castagnoliSSE42(SB), NOSPLIT, $0 + MOVL crc+0(FP), AX // CRC value + MOVQ p+8(FP), SI // data pointer + MOVQ p_len+16(FP), CX // len(p) + + // If there are fewer than 8 bytes to process, skip alignment. + CMPQ CX, $8 + JL less_than_8 + + MOVQ SI, BX + ANDQ $7, BX + JZ aligned + + // Process the first few bytes to 8-byte align the input. + + // BX = 8 - BX. We need to process this many bytes to align. + SUBQ $1, BX + XORQ $7, BX + + BTQ $0, BX + JNC align_2 + + CRC32B (SI), AX + DECQ CX + INCQ SI + +align_2: + BTQ $1, BX + JNC align_4 + + CRC32W (SI), AX + + SUBQ $2, CX + ADDQ $2, SI + +align_4: + BTQ $2, BX + JNC aligned + + CRC32L (SI), AX + + SUBQ $4, CX + ADDQ $4, SI + +aligned: + // The input is now 8-byte aligned and we can process 8-byte chunks. + CMPQ CX, $8 + JL less_than_8 + + CRC32Q (SI), AX + ADDQ $8, SI + SUBQ $8, CX + JMP aligned + +less_than_8: + // We may have some bytes left over; process 4 bytes, then 2, then 1. + BTQ $2, CX + JNC less_than_4 + + CRC32L (SI), AX + ADDQ $4, SI + +less_than_4: + BTQ $1, CX + JNC less_than_2 + + CRC32W (SI), AX + ADDQ $2, SI + +less_than_2: + BTQ $0, CX + JNC done + + CRC32B (SI), AX + +done: + MOVL AX, ret+32(FP) + RET + +// castagnoliSSE42Triple updates three (non-inverted) crcs with (24*rounds) +// bytes from each buffer. +// +// func castagnoliSSE42Triple( +// crc1, crc2, crc3 uint32, +// a, b, c []byte, +// rounds uint32, +// ) (retA uint32, retB uint32, retC uint32) +TEXT ·castagnoliSSE42Triple(SB), NOSPLIT, $0 + MOVL crcA+0(FP), AX + MOVL crcB+4(FP), CX + MOVL crcC+8(FP), DX + + MOVQ a+16(FP), R8 // data pointer + MOVQ b+40(FP), R9 // data pointer + MOVQ c+64(FP), R10 // data pointer + + MOVL rounds+88(FP), R11 + +loop: + CRC32Q (R8), AX + CRC32Q (R9), CX + CRC32Q (R10), DX + + CRC32Q 8(R8), AX + CRC32Q 8(R9), CX + CRC32Q 8(R10), DX + + CRC32Q 16(R8), AX + CRC32Q 16(R9), CX + CRC32Q 16(R10), DX + + ADDQ $24, R8 + ADDQ $24, R9 + ADDQ $24, R10 + + DECQ R11 + JNZ loop + + MOVL AX, retA+96(FP) + MOVL CX, retB+100(FP) + MOVL DX, retC+104(FP) + RET + +// CRC32 polynomial data +// +// These constants are lifted from the +// Linux kernel, since they avoid the costly +// PSHUFB 16 byte reversal proposed in the +// original Intel paper. +DATA r2r1<>+0(SB)/8, $0x154442bd4 +DATA r2r1<>+8(SB)/8, $0x1c6e41596 +DATA r4r3<>+0(SB)/8, $0x1751997d0 +DATA r4r3<>+8(SB)/8, $0x0ccaa009e +DATA rupoly<>+0(SB)/8, $0x1db710641 +DATA rupoly<>+8(SB)/8, $0x1f7011641 +DATA r5<>+0(SB)/8, $0x163cd6124 + +GLOBL r2r1<>(SB), RODATA, $16 +GLOBL r4r3<>(SB), RODATA, $16 +GLOBL rupoly<>(SB), RODATA, $16 +GLOBL r5<>(SB), RODATA, $8 + +// Based on https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf +// len(p) must be at least 64, and must be a multiple of 16. + +// func ieeeCLMUL(crc uint32, p []byte) uint32 +TEXT ·ieeeCLMUL(SB), NOSPLIT, $0 + MOVL crc+0(FP), X0 // Initial CRC value + MOVQ p+8(FP), SI // data pointer + MOVQ p_len+16(FP), CX // len(p) + + MOVOU (SI), X1 + MOVOU 16(SI), X2 + MOVOU 32(SI), X3 + MOVOU 48(SI), X4 + PXOR X0, X1 + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + CMPQ CX, $64 // Less than 64 bytes left + JB remain64 + + MOVOA r2r1<>+0(SB), X0 + +loopback64: + MOVOA X1, X5 + MOVOA X2, X6 + MOVOA X3, X7 + MOVOA X4, X8 + + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0, X0, X2 + PCLMULQDQ $0, X0, X3 + PCLMULQDQ $0, X0, X4 + + // Load next early + MOVOU (SI), X11 + MOVOU 16(SI), X12 + MOVOU 32(SI), X13 + MOVOU 48(SI), X14 + + PCLMULQDQ $0x11, X0, X5 + PCLMULQDQ $0x11, X0, X6 + PCLMULQDQ $0x11, X0, X7 + PCLMULQDQ $0x11, X0, X8 + + PXOR X5, X1 + PXOR X6, X2 + PXOR X7, X3 + PXOR X8, X4 + + PXOR X11, X1 + PXOR X12, X2 + PXOR X13, X3 + PXOR X14, X4 + + ADDQ $0x40, DI + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + CMPQ CX, $64 // Less than 64 bytes left? + JGE loopback64 + + // Fold result into a single register (X1) +remain64: + MOVOA r4r3<>+0(SB), X0 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X2, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X3, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X4, X1 + + // If there is less than 16 bytes left we are done + CMPQ CX, $16 + JB finish + + // Encode 16 bytes +remain16: + MOVOU (SI), X10 + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X10, X1 + SUBQ $16, CX + ADDQ $16, SI + CMPQ CX, $16 + JGE remain16 + +finish: + // Fold final result into 32 bits and return it + PCMPEQB X3, X3 + PCLMULQDQ $1, X1, X0 + PSRLDQ $8, X1 + PXOR X0, X1 + + MOVOA X1, X2 + MOVQ r5<>+0(SB), X0 + + // Creates 32 bit mask. Note that we don't care about upper half. + PSRLQ $32, X3 + + PSRLDQ $4, X2 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + MOVOA rupoly<>+0(SB), X0 + + MOVOA X1, X2 + PAND X3, X1 + PCLMULQDQ $0x10, X0, X1 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + PEXTRD $1, X1, AX + MOVL AX, ret+32(FP) + + RET + +DATA r2r1X<>+0(SB)/8, $0x154442bd4 +DATA r2r1X<>+8(SB)/8, $0x1c6e41596 +DATA r2r1X<>+16(SB)/8, $0x154442bd4 +DATA r2r1X<>+24(SB)/8, $0x1c6e41596 +DATA r2r1X<>+32(SB)/8, $0x154442bd4 +DATA r2r1X<>+40(SB)/8, $0x1c6e41596 +DATA r2r1X<>+48(SB)/8, $0x154442bd4 +DATA r2r1X<>+56(SB)/8, $0x1c6e41596 +GLOBL r2r1X<>(SB), RODATA, $64 + +// Based on https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf +// len(p) must be at least 128, and must be a multiple of 16. + +// func ieeeCLMULAvx512(crc uint32, p []byte) uint32 +TEXT ·ieeeCLMULAvx512(SB), NOSPLIT, $0 + MOVL crc+0(FP), AX // Initial CRC value + MOVQ p+8(FP), SI // data pointer + MOVQ p_len+16(FP), CX // len(p) + + VPXORQ Z0, Z0, Z0 + VMOVDQU64 (SI), Z1 + VMOVQ AX, X0 + VPXORQ Z0, Z1, Z1 // Merge initial CRC value into Z1 + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + + VMOVDQU64 r2r1X<>+0(SB), Z0 + +loopback64: + // Load next early + VMOVDQU64 (SI), Z11 + + VPCLMULQDQ $0x11, Z0, Z1, Z5 + VPCLMULQDQ $0, Z0, Z1, Z1 + + VPTERNLOGD $0x96, Z11, Z5, Z1 // Combine results with xor into Z1 + + ADDQ $0x40, DI + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + CMPQ CX, $64 // Less than 64 bytes left? + JGE loopback64 + + // Fold result into a single register (X1) +remain64: + VEXTRACTF32X4 $1, Z1, X2 // X2: Second 128-bit lane + VEXTRACTF32X4 $2, Z1, X3 // X3: Third 128-bit lane + VEXTRACTF32X4 $3, Z1, X4 // X4: Fourth 128-bit lane + + MOVOA r4r3<>+0(SB), X0 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X2, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X3, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X4, X1 + + // If there is less than 16 bytes left we are done + CMPQ CX, $16 + JB finish + + // Encode 16 bytes +remain16: + MOVOU (SI), X10 + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X10, X1 + SUBQ $16, CX + ADDQ $16, SI + CMPQ CX, $16 + JGE remain16 + +finish: + // Fold final result into 32 bits and return it + PCMPEQB X3, X3 + PCLMULQDQ $1, X1, X0 + PSRLDQ $8, X1 + PXOR X0, X1 + + MOVOA X1, X2 + MOVQ r5<>+0(SB), X0 + + // Creates 32 bit mask. Note that we don't care about upper half. + PSRLQ $32, X3 + + PSRLDQ $4, X2 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + MOVOA rupoly<>+0(SB), X0 + + MOVOA X1, X2 + PAND X3, X1 + PCLMULQDQ $0x10, X0, X1 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + PEXTRD $1, X1, AX + MOVL AX, ret+32(FP) + VZEROUPPER + RET + +// Castagonli Polynomial constants +DATA r2r1C<>+0(SB)/8, $0x0740eef02 +DATA r2r1C<>+8(SB)/8, $0x09e4addf8 +DATA r2r1C<>+16(SB)/8, $0x0740eef02 +DATA r2r1C<>+24(SB)/8, $0x09e4addf8 +DATA r2r1C<>+32(SB)/8, $0x0740eef02 +DATA r2r1C<>+40(SB)/8, $0x09e4addf8 +DATA r2r1C<>+48(SB)/8, $0x0740eef02 +DATA r2r1C<>+56(SB)/8, $0x09e4addf8 +GLOBL r2r1C<>(SB), RODATA, $64 + +DATA r4r3C<>+0(SB)/8, $0xf20c0dfe +DATA r4r3C<>+8(SB)/8, $0x14cd00bd6 +DATA rupolyC<>+0(SB)/8, $0x105ec76f0 +DATA rupolyC<>+8(SB)/8, $0xdea713f1 +DATA r5C<>+0(SB)/8, $0xdd45aab8 + +GLOBL r4r3C<>(SB), RODATA, $16 +GLOBL rupolyC<>(SB), RODATA, $16 +GLOBL r5C<>(SB), RODATA, $8 + +// Based on https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf +// len(p) must be at least 128, and must be a multiple of 16. + +// func castagnoliCLMULAvx512(crc uint32, p []byte) uint32 +TEXT ·castagnoliCLMULAvx512(SB), NOSPLIT, $0 + MOVL crc+0(FP), AX // Initial CRC value + MOVQ p+8(FP), SI // data pointer + MOVQ p_len+16(FP), CX // len(p) + + VPXORQ Z0, Z0, Z0 + VMOVDQU64 (SI), Z1 + VMOVQ AX, X0 + VPXORQ Z0, Z1, Z1 // Merge initial CRC value into Z1 + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + + VMOVDQU64 r2r1C<>+0(SB), Z0 + +loopback64: + // Load next early + VMOVDQU64 (SI), Z11 + + VPCLMULQDQ $0x11, Z0, Z1, Z5 + VPCLMULQDQ $0, Z0, Z1, Z1 + + VPTERNLOGD $0x96, Z11, Z5, Z1 // Combine results with xor into Z1 + + ADDQ $0x40, DI + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + CMPQ CX, $64 // Less than 64 bytes left? + JGE loopback64 + + // Fold result into a single register (X1) +remain64: + VEXTRACTF32X4 $1, Z1, X2 // X2: Second 128-bit lane + VEXTRACTF32X4 $2, Z1, X3 // X3: Third 128-bit lane + VEXTRACTF32X4 $3, Z1, X4 // X4: Fourth 128-bit lane + + MOVOA r4r3C<>+0(SB), X0 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X2, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X3, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X4, X1 + + // If there is less than 16 bytes left we are done + CMPQ CX, $16 + JB finish + + // Encode 16 bytes +remain16: + MOVOU (SI), X10 + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X10, X1 + SUBQ $16, CX + ADDQ $16, SI + CMPQ CX, $16 + JGE remain16 + +finish: + // Fold final result into 32 bits and return it + PCMPEQB X3, X3 + PCLMULQDQ $1, X1, X0 + PSRLDQ $8, X1 + PXOR X0, X1 + + MOVOA X1, X2 + MOVQ r5C<>+0(SB), X0 + + // Creates 32 bit mask. Note that we don't care about upper half. + PSRLQ $32, X3 + + PSRLDQ $4, X2 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + MOVOA rupolyC<>+0(SB), X0 + + MOVOA X1, X2 + PAND X3, X1 + PCLMULQDQ $0x10, X0, X1 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + PEXTRD $1, X1, AX + MOVL AX, ret+32(FP) + VZEROUPPER + RET diff --git a/vendor/github.com/klauspost/crc32/crc32_arm64.go b/vendor/github.com/klauspost/crc32/crc32_arm64.go new file mode 100644 index 000000000..7e9ac5539 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_arm64.go @@ -0,0 +1,50 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// ARM64-specific hardware-assisted CRC32 algorithms. See crc32.go for a +// description of the interface that each architecture-specific file +// implements. + +package crc32 + +import "golang.org/x/sys/cpu" + +func castagnoliUpdate(crc uint32, p []byte) uint32 +func ieeeUpdate(crc uint32, p []byte) uint32 + +func archAvailableCastagnoli() bool { + return cpu.ARM64.HasCRC32 +} + +func archInitCastagnoli() { + if !cpu.ARM64.HasCRC32 { + panic("arch-specific crc32 instruction for Castagnoli not available") + } +} + +func archUpdateCastagnoli(crc uint32, p []byte) uint32 { + if !cpu.ARM64.HasCRC32 { + panic("arch-specific crc32 instruction for Castagnoli not available") + } + + return ^castagnoliUpdate(^crc, p) +} + +func archAvailableIEEE() bool { + return cpu.ARM64.HasCRC32 +} + +func archInitIEEE() { + if !cpu.ARM64.HasCRC32 { + panic("arch-specific crc32 instruction for IEEE not available") + } +} + +func archUpdateIEEE(crc uint32, p []byte) uint32 { + if !cpu.ARM64.HasCRC32 { + panic("arch-specific crc32 instruction for IEEE not available") + } + + return ^ieeeUpdate(^crc, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_arm64.s b/vendor/github.com/klauspost/crc32/crc32_arm64.s new file mode 100644 index 000000000..e82778f7b --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_arm64.s @@ -0,0 +1,97 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "textflag.h" + +// castagnoliUpdate updates the non-inverted crc with the given data. + +// func castagnoliUpdate(crc uint32, p []byte) uint32 +TEXT ·castagnoliUpdate(SB), NOSPLIT, $0-36 + MOVWU crc+0(FP), R9 // CRC value + MOVD p+8(FP), R13 // data pointer + MOVD p_len+16(FP), R11 // len(p) + +update: + CMP $16, R11 + BLT less_than_16 + LDP.P 16(R13), (R8, R10) + CRC32CX R8, R9 + CRC32CX R10, R9 + SUB $16, R11 + + JMP update + +less_than_16: + TBZ $3, R11, less_than_8 + + MOVD.P 8(R13), R10 + CRC32CX R10, R9 + +less_than_8: + TBZ $2, R11, less_than_4 + + MOVWU.P 4(R13), R10 + CRC32CW R10, R9 + +less_than_4: + TBZ $1, R11, less_than_2 + + MOVHU.P 2(R13), R10 + CRC32CH R10, R9 + +less_than_2: + TBZ $0, R11, done + + MOVBU (R13), R10 + CRC32CB R10, R9 + +done: + MOVWU R9, ret+32(FP) + RET + +// ieeeUpdate updates the non-inverted crc with the given data. + +// func ieeeUpdate(crc uint32, p []byte) uint32 +TEXT ·ieeeUpdate(SB), NOSPLIT, $0-36 + MOVWU crc+0(FP), R9 // CRC value + MOVD p+8(FP), R13 // data pointer + MOVD p_len+16(FP), R11 // len(p) + +update: + CMP $16, R11 + BLT less_than_16 + LDP.P 16(R13), (R8, R10) + CRC32X R8, R9 + CRC32X R10, R9 + SUB $16, R11 + + JMP update + +less_than_16: + TBZ $3, R11, less_than_8 + + MOVD.P 8(R13), R10 + CRC32X R10, R9 + +less_than_8: + TBZ $2, R11, less_than_4 + + MOVWU.P 4(R13), R10 + CRC32W R10, R9 + +less_than_4: + TBZ $1, R11, less_than_2 + + MOVHU.P 2(R13), R10 + CRC32H R10, R9 + +less_than_2: + TBZ $0, R11, done + + MOVBU (R13), R10 + CRC32B R10, R9 + +done: + MOVWU R9, ret+32(FP) + RET diff --git a/vendor/github.com/klauspost/crc32/crc32_generic.go b/vendor/github.com/klauspost/crc32/crc32_generic.go new file mode 100644 index 000000000..d1cf69cf4 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_generic.go @@ -0,0 +1,91 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// This file contains CRC32 algorithms that are not specific to any architecture +// and don't use hardware acceleration. +// +// The simple (and slow) CRC32 implementation only uses a 256*4 bytes table. +// +// The slicing-by-8 algorithm is a faster implementation that uses a bigger +// table (8*256*4 bytes). + +package crc32 + +import "encoding/binary" + +// simpleMakeTable allocates and constructs a Table for the specified +// polynomial. The table is suitable for use with the simple algorithm +// (simpleUpdate). +func simpleMakeTable(poly uint32) *Table { + t := new(Table) + simplePopulateTable(poly, t) + return t +} + +// simplePopulateTable constructs a Table for the specified polynomial, suitable +// for use with simpleUpdate. +func simplePopulateTable(poly uint32, t *Table) { + for i := 0; i < 256; i++ { + crc := uint32(i) + for j := 0; j < 8; j++ { + if crc&1 == 1 { + crc = (crc >> 1) ^ poly + } else { + crc >>= 1 + } + } + t[i] = crc + } +} + +// simpleUpdate uses the simple algorithm to update the CRC, given a table that +// was previously computed using simpleMakeTable. +func simpleUpdate(crc uint32, tab *Table, p []byte) uint32 { + crc = ^crc + for _, v := range p { + crc = tab[byte(crc)^v] ^ (crc >> 8) + } + return ^crc +} + +// Use slicing-by-8 when payload >= this value. +const slicing8Cutoff = 16 + +// slicing8Table is array of 8 Tables, used by the slicing-by-8 algorithm. +type slicing8Table [8]Table + +// slicingMakeTable constructs a slicing8Table for the specified polynomial. The +// table is suitable for use with the slicing-by-8 algorithm (slicingUpdate). +func slicingMakeTable(poly uint32) *slicing8Table { + t := new(slicing8Table) + simplePopulateTable(poly, &t[0]) + for i := 0; i < 256; i++ { + crc := t[0][i] + for j := 1; j < 8; j++ { + crc = t[0][crc&0xFF] ^ (crc >> 8) + t[j][i] = crc + } + } + return t +} + +// slicingUpdate uses the slicing-by-8 algorithm to update the CRC, given a +// table that was previously computed using slicingMakeTable. +func slicingUpdate(crc uint32, tab *slicing8Table, p []byte) uint32 { + if len(p) >= slicing8Cutoff { + crc = ^crc + for len(p) > 8 { + crc ^= binary.LittleEndian.Uint32(p) + crc = tab[0][p[7]] ^ tab[1][p[6]] ^ tab[2][p[5]] ^ tab[3][p[4]] ^ + tab[4][crc>>24] ^ tab[5][(crc>>16)&0xFF] ^ + tab[6][(crc>>8)&0xFF] ^ tab[7][crc&0xFF] + p = p[8:] + } + crc = ^crc + } + if len(p) == 0 { + return crc + } + return simpleUpdate(crc, &tab[0], p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_loong64.go b/vendor/github.com/klauspost/crc32/crc32_loong64.go new file mode 100644 index 000000000..3e0fd9778 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_loong64.go @@ -0,0 +1,50 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// LoongArch64-specific hardware-assisted CRC32 algorithms. See crc32.go for a +// description of the interface that each architecture-specific file +// implements. + +package crc32 + +import "golang.org/x/sys/cpu" + +func castagnoliUpdate(crc uint32, p []byte) uint32 +func ieeeUpdate(crc uint32, p []byte) uint32 + +func archAvailableCastagnoli() bool { + return cpu.Loong64.HasCRC32 +} + +func archInitCastagnoli() { + if !cpu.Loong64.HasCRC32 { + panic("arch-specific crc32 instruction for Castagnoli not available") + } +} + +func archUpdateCastagnoli(crc uint32, p []byte) uint32 { + if !cpu.Loong64.HasCRC32 { + panic("arch-specific crc32 instruction for Castagnoli not available") + } + + return ^castagnoliUpdate(^crc, p) +} + +func archAvailableIEEE() bool { + return cpu.Loong64.HasCRC32 +} + +func archInitIEEE() { + if !cpu.Loong64.HasCRC32 { + panic("arch-specific crc32 instruction for IEEE not available") + } +} + +func archUpdateIEEE(crc uint32, p []byte) uint32 { + if !cpu.Loong64.HasCRC32 { + panic("arch-specific crc32 instruction for IEEE not available") + } + + return ^ieeeUpdate(^crc, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_loong64.s b/vendor/github.com/klauspost/crc32/crc32_loong64.s new file mode 100644 index 000000000..7165714dc --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_loong64.s @@ -0,0 +1,160 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "textflag.h" + +// castagnoliUpdate updates the non-inverted crc with the given data. + +// func castagnoliUpdate(crc uint32, p []byte) uint32 +TEXT ·castagnoliUpdate(SB), NOSPLIT, $0-36 + MOVWU crc+0(FP), R4 // a0 = CRC value + MOVV p+8(FP), R5 // a1 = data pointer + MOVV p_len+16(FP), R6 // a2 = len(p) + + SGT $8, R6, R12 + BNE R12, less_than_8 + AND $7, R5, R12 + BEQ R12, aligned + + // Process the first few bytes to 8-byte align the input. + // t0 = 8 - t0. We need to process this many bytes to align. + SUB $1, R12 + XOR $7, R12 + + AND $1, R12, R13 + BEQ R13, align_2 + MOVB (R5), R13 + CRCCWBW R4, R13, R4 + ADDV $1, R5 + ADDV $-1, R6 + +align_2: + AND $2, R12, R13 + BEQ R13, align_4 + MOVH (R5), R13 + CRCCWHW R4, R13, R4 + ADDV $2, R5 + ADDV $-2, R6 + +align_4: + AND $4, R12, R13 + BEQ R13, aligned + MOVW (R5), R13 + CRCCWWW R4, R13, R4 + ADDV $4, R5 + ADDV $-4, R6 + +aligned: + // The input is now 8-byte aligned and we can process 8-byte chunks. + SGT $8, R6, R12 + BNE R12, less_than_8 + MOVV (R5), R13 + CRCCWVW R4, R13, R4 + ADDV $8, R5 + ADDV $-8, R6 + JMP aligned + +less_than_8: + // We may have some bytes left over; process 4 bytes, then 2, then 1. + AND $4, R6, R12 + BEQ R12, less_than_4 + MOVW (R5), R13 + CRCCWWW R4, R13, R4 + ADDV $4, R5 + ADDV $-4, R6 + +less_than_4: + AND $2, R6, R12 + BEQ R12, less_than_2 + MOVH (R5), R13 + CRCCWHW R4, R13, R4 + ADDV $2, R5 + ADDV $-2, R6 + +less_than_2: + BEQ R6, done + MOVB (R5), R13 + CRCCWBW R4, R13, R4 + +done: + MOVW R4, ret+32(FP) + RET + +// ieeeUpdate updates the non-inverted crc with the given data. + +// func ieeeUpdate(crc uint32, p []byte) uint32 +TEXT ·ieeeUpdate(SB), NOSPLIT, $0-36 + MOVWU crc+0(FP), R4 // a0 = CRC value + MOVV p+8(FP), R5 // a1 = data pointer + MOVV p_len+16(FP), R6 // a2 = len(p) + + SGT $8, R6, R12 + BNE R12, less_than_8 + AND $7, R5, R12 + BEQ R12, aligned + + // Process the first few bytes to 8-byte align the input. + // t0 = 8 - t0. We need to process this many bytes to align. + SUB $1, R12 + XOR $7, R12 + + AND $1, R12, R13 + BEQ R13, align_2 + MOVB (R5), R13 + CRCWBW R4, R13, R4 + ADDV $1, R5 + ADDV $-1, R6 + +align_2: + AND $2, R12, R13 + BEQ R13, align_4 + MOVH (R5), R13 + CRCWHW R4, R13, R4 + ADDV $2, R5 + ADDV $-2, R6 + +align_4: + AND $4, R12, R13 + BEQ R13, aligned + MOVW (R5), R13 + CRCWWW R4, R13, R4 + ADDV $4, R5 + ADDV $-4, R6 + +aligned: + // The input is now 8-byte aligned and we can process 8-byte chunks. + SGT $8, R6, R12 + BNE R12, less_than_8 + MOVV (R5), R13 + CRCWVW R4, R13, R4 + ADDV $8, R5 + ADDV $-8, R6 + JMP aligned + +less_than_8: + // We may have some bytes left over; process 4 bytes, then 2, then 1. + AND $4, R6, R12 + BEQ R12, less_than_4 + MOVW (R5), R13 + CRCWWW R4, R13, R4 + ADDV $4, R5 + ADDV $-4, R6 + +less_than_4: + AND $2, R6, R12 + BEQ R12, less_than_2 + MOVH (R5), R13 + CRCWHW R4, R13, R4 + ADDV $2, R5 + ADDV $-2, R6 + +less_than_2: + BEQ R6, done + MOVB (R5), R13 + CRCWBW R4, R13, R4 + +done: + MOVW R4, ret+32(FP) + RET + diff --git a/vendor/github.com/klauspost/crc32/crc32_otherarch.go b/vendor/github.com/klauspost/crc32/crc32_otherarch.go new file mode 100644 index 000000000..f900968ad --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_otherarch.go @@ -0,0 +1,15 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build !amd64 && !s390x && !ppc64le && !arm64 && !loong64 + +package crc32 + +func archAvailableIEEE() bool { return false } +func archInitIEEE() { panic("not available") } +func archUpdateIEEE(crc uint32, p []byte) uint32 { panic("not available") } + +func archAvailableCastagnoli() bool { return false } +func archInitCastagnoli() { panic("not available") } +func archUpdateCastagnoli(crc uint32, p []byte) uint32 { panic("not available") } diff --git a/vendor/github.com/klauspost/crc32/crc32_ppc64le.go b/vendor/github.com/klauspost/crc32/crc32_ppc64le.go new file mode 100644 index 000000000..c22e38e00 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_ppc64le.go @@ -0,0 +1,88 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package crc32 + +import ( + "unsafe" +) + +const ( + vecMinLen = 16 + vecAlignMask = 15 // align to 16 bytes + crcIEEE = 1 + crcCast = 2 +) + +//go:noescape +func ppc64SlicingUpdateBy8(crc uint32, table8 *slicing8Table, p []byte) uint32 + +// this function requires the buffer to be 16 byte aligned and > 16 bytes long. +// +//go:noescape +func vectorCrc32(crc uint32, poly uint32, p []byte) uint32 + +var archCastagnoliTable8 *slicing8Table + +func archInitCastagnoli() { + archCastagnoliTable8 = slicingMakeTable(Castagnoli) +} + +func archUpdateCastagnoli(crc uint32, p []byte) uint32 { + if len(p) >= 4*vecMinLen { + // If not aligned then process the initial unaligned bytes + + if uint64(uintptr(unsafe.Pointer(&p[0])))&uint64(vecAlignMask) != 0 { + align := uint64(uintptr(unsafe.Pointer(&p[0]))) & uint64(vecAlignMask) + newlen := vecMinLen - align + crc = ppc64SlicingUpdateBy8(crc, archCastagnoliTable8, p[:newlen]) + p = p[newlen:] + } + // p should be aligned now + aligned := len(p) & ^vecAlignMask + crc = vectorCrc32(crc, crcCast, p[:aligned]) + p = p[aligned:] + } + if len(p) == 0 { + return crc + } + return ppc64SlicingUpdateBy8(crc, archCastagnoliTable8, p) +} + +func archAvailableIEEE() bool { + return true +} +func archAvailableCastagnoli() bool { + return true +} + +var archIeeeTable8 *slicing8Table + +func archInitIEEE() { + // We still use slicing-by-8 for small buffers. + archIeeeTable8 = slicingMakeTable(IEEE) +} + +// archUpdateIEEE calculates the checksum of p using vectorizedIEEE. +func archUpdateIEEE(crc uint32, p []byte) uint32 { + + // Check if vector code should be used. If not aligned, then handle those + // first up to the aligned bytes. + + if len(p) >= 4*vecMinLen { + if uint64(uintptr(unsafe.Pointer(&p[0])))&uint64(vecAlignMask) != 0 { + align := uint64(uintptr(unsafe.Pointer(&p[0]))) & uint64(vecAlignMask) + newlen := vecMinLen - align + crc = ppc64SlicingUpdateBy8(crc, archIeeeTable8, p[:newlen]) + p = p[newlen:] + } + aligned := len(p) & ^vecAlignMask + crc = vectorCrc32(crc, crcIEEE, p[:aligned]) + p = p[aligned:] + } + if len(p) == 0 { + return crc + } + return ppc64SlicingUpdateBy8(crc, archIeeeTable8, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_ppc64le.s b/vendor/github.com/klauspost/crc32/crc32_ppc64le.s new file mode 100644 index 000000000..87edef705 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_ppc64le.s @@ -0,0 +1,736 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// The vectorized implementation found below is a derived work +// from code written by Anton Blanchard <anton@au.ibm.com> found +// at https://github.com/antonblanchard/crc32-vpmsum. The original +// is dual licensed under GPL and Apache 2. As the copyright holder +// for the work, IBM has contributed this new work under +// the golang license. + +// Changes include porting to Go assembler with modifications for +// the Go ABI for ppc64le. + +#include "textflag.h" + +#define POWER8_OFFSET 132 + +#define off16 R16 +#define off32 R17 +#define off48 R18 +#define off64 R19 +#define off80 R20 +#define off96 R21 +#define off112 R22 + +#define const1 V24 +#define const2 V25 + +#define byteswap V26 +#define mask_32bit V27 +#define mask_64bit V28 +#define zeroes V29 + +#define MAX_SIZE 32*1024 +#define REFLECT + +TEXT ·ppc64SlicingUpdateBy8(SB), NOSPLIT|NOFRAME, $0-44 + MOVWZ crc+0(FP), R3 // incoming crc + MOVD table8+8(FP), R4 // *Table + MOVD p+16(FP), R5 + MOVD p_len+24(FP), R6 // p len + + CMP $0, R6 // len == 0? + BNE start + MOVW R3, ret+40(FP) // return crc + RET + +start: + NOR R3, R3, R7 // ^crc + MOVWZ R7, R7 // 32 bits + CMP R6, $16 + MOVD R6, CTR + BLT short + SRAD $3, R6, R8 // 8 byte chunks + MOVD R8, CTR + +loop: + MOVWZ 0(R5), R8 // 0-3 bytes of p ?Endian? + MOVWZ 4(R5), R9 // 4-7 bytes of p + MOVD R4, R10 // &tab[0] + XOR R7, R8, R7 // crc ^= byte[0:3] + RLDICL $40, R9, $56, R17 // p[7] + SLD $2, R17, R17 // p[7]*4 + RLDICL $40, R7, $56, R8 // crc>>24 + SLD $2, R8, R8 // crc>>24*4 + RLDICL $48, R9, $56, R18 // p[6] + SLD $2, R18, R18 // p[6]*4 + MOVWZ (R10)(R17), R21 // tab[0][p[7]] + ADD $1024, R10, R10 // tab[1] + RLDICL $56, R9, $56, R19 // p[5] + SLD $2, R19, R19 // p[5]*4:1 + MOVWZ (R10)(R18), R22 // tab[1][p[6]] + ADD $1024, R10, R10 // tab[2] + XOR R21, R22, R21 // xor done R22 + CLRLSLDI $56, R9, $2, R20 + MOVWZ (R10)(R19), R23 // tab[2][p[5]] + ADD $1024, R10, R10 // &tab[3] + XOR R21, R23, R21 // xor done R23 + MOVWZ (R10)(R20), R24 // tab[3][p[4]] + ADD $1024, R10, R10 // &tab[4] + XOR R21, R24, R21 // xor done R24 + MOVWZ (R10)(R8), R25 // tab[4][crc>>24] + RLDICL $48, R7, $56, R24 // crc>>16&0xFF + XOR R21, R25, R21 // xor done R25 + ADD $1024, R10, R10 // &tab[5] + SLD $2, R24, R24 // crc>>16&0xFF*4 + MOVWZ (R10)(R24), R26 // tab[5][crc>>16&0xFF] + XOR R21, R26, R21 // xor done R26 + RLDICL $56, R7, $56, R25 // crc>>8 + ADD $1024, R10, R10 // &tab[6] + SLD $2, R25, R25 // crc>>8&FF*2 + MOVBZ R7, R26 // crc&0xFF + MOVWZ (R10)(R25), R27 // tab[6][crc>>8&0xFF] + ADD $1024, R10, R10 // &tab[7] + SLD $2, R26, R26 // crc&0xFF*2 + XOR R21, R27, R21 // xor done R27 + ADD $8, R5 // p = p[8:] + MOVWZ (R10)(R26), R28 // tab[7][crc&0xFF] + XOR R21, R28, R21 // xor done R28 + MOVWZ R21, R7 // crc for next round + BDNZ loop + ANDCC $7, R6, R8 // any leftover bytes + BEQ done // none --> done + MOVD R8, CTR // byte count + PCALIGN $16 // align short loop + +short: + MOVBZ 0(R5), R8 // get v + XOR R8, R7, R8 // byte(crc)^v -> R8 + RLDIC $2, R8, $54, R8 // rldicl r8,r8,2,22 + SRD $8, R7, R14 // crc>>8 + MOVWZ (R4)(R8), R10 + ADD $1, R5 + XOR R10, R14, R7 // loop crc in R7 + BDNZ short + +done: + NOR R7, R7, R7 // ^crc + MOVW R7, ret+40(FP) // return crc + RET + +#ifdef BYTESWAP_DATA +DATA ·byteswapcons+0(SB)/8, $0x0706050403020100 +DATA ·byteswapcons+8(SB)/8, $0x0f0e0d0c0b0a0908 + +GLOBL ·byteswapcons+0(SB), RODATA, $16 +#endif + +TEXT ·vectorCrc32(SB), NOSPLIT|NOFRAME, $0-36 + MOVWZ crc+0(FP), R3 // incoming crc + MOVWZ ctab+4(FP), R14 // crc poly id + MOVD p+8(FP), R4 + MOVD p_len+16(FP), R5 // p len + + // R3 = incoming crc + // R14 = constant table identifier + // R5 = address of bytes + // R6 = length of bytes + + // defines for index loads + + MOVD $16, off16 + MOVD $32, off32 + MOVD $48, off48 + MOVD $64, off64 + MOVD $80, off80 + MOVD $96, off96 + MOVD $112, off112 + MOVD $0, R15 + + MOVD R3, R10 // save initial crc + + NOR R3, R3, R3 // ^crc + MOVWZ R3, R3 // 32 bits + VXOR zeroes, zeroes, zeroes // clear the V reg + VSPLTISW $-1, V0 + VSLDOI $4, V29, V0, mask_32bit + VSLDOI $8, V29, V0, mask_64bit + + VXOR V8, V8, V8 + MTVSRD R3, VS40 // crc initial value VS40 = V8 + +#ifdef REFLECT + VSLDOI $8, zeroes, V8, V8 // or: VSLDOI V29,V8,V27,4 for top 32 bits? + +#else + VSLDOI $4, V8, zeroes, V8 + +#endif + +#ifdef BYTESWAP_DATA + MOVD $·byteswapcons(SB), R3 + LVX (R3), byteswap + +#endif + + CMPU R5, $256 // length of bytes + BLT short + + RLDICR $0, R5, $56, R6 // chunk to process + + // First step for larger sizes +l1: + MOVD $32768, R7 + MOVD R7, R9 + CMP R6, R7 // compare R6, R7 (MAX SIZE) + BGT top // less than MAX, just do remainder + MOVD R6, R7 + +top: + SUB R7, R6, R6 + + // mainloop does 128 bytes at a time + SRD $7, R7 + + // determine the offset into the constants table to start with. + // Each constant is 128 bytes, used against 16 bytes of data. + SLD $4, R7, R8 + SRD $3, R9, R9 + SUB R8, R9, R8 + + // The last iteration is reduced in a separate step + ADD $-1, R7 + MOVD R7, CTR + + // Determine which constant table (depends on poly) + CMP R14, $1 + BNE castTable + MOVD $·IEEEConst(SB), R3 + BR startConst + +castTable: + MOVD $·CastConst(SB), R3 + +startConst: + ADD R3, R8, R3 // starting point in constants table + + VXOR V0, V0, V0 // clear the V regs + VXOR V1, V1, V1 + VXOR V2, V2, V2 + VXOR V3, V3, V3 + VXOR V4, V4, V4 + VXOR V5, V5, V5 + VXOR V6, V6, V6 + VXOR V7, V7, V7 + + LVX (R3), const1 // loading constant values + + CMP R15, $1 // Identify warm up pass + BEQ next + + // First warm up pass: load the bytes to process + LVX (R4), V16 + LVX (R4+off16), V17 + LVX (R4+off32), V18 + LVX (R4+off48), V19 + LVX (R4+off64), V20 + LVX (R4+off80), V21 + LVX (R4+off96), V22 + LVX (R4+off112), V23 + ADD $128, R4 // bump up to next 128 bytes in buffer + + VXOR V16, V8, V16 // xor in initial CRC in V8 + +next: + BC 18, 0, first_warm_up_done + + ADD $16, R3 // bump up to next constants + LVX (R3), const2 // table values + + VPMSUMD V16, const1, V8 // second warm up pass + LVX (R4), V16 // load from buffer + OR $0, R2, R2 + + VPMSUMD V17, const1, V9 // vpmsumd with constants + LVX (R4+off16), V17 // load next from buffer + OR $0, R2, R2 + + VPMSUMD V18, const1, V10 // vpmsumd with constants + LVX (R4+off32), V18 // load next from buffer + OR $0, R2, R2 + + VPMSUMD V19, const1, V11 // vpmsumd with constants + LVX (R4+off48), V19 // load next from buffer + OR $0, R2, R2 + + VPMSUMD V20, const1, V12 // vpmsumd with constants + LVX (R4+off64), V20 // load next from buffer + OR $0, R2, R2 + + VPMSUMD V21, const1, V13 // vpmsumd with constants + LVX (R4+off80), V21 // load next from buffer + OR $0, R2, R2 + + VPMSUMD V22, const1, V14 // vpmsumd with constants + LVX (R4+off96), V22 // load next from buffer + OR $0, R2, R2 + + VPMSUMD V23, const1, V15 // vpmsumd with constants + LVX (R4+off112), V23 // load next from buffer + + ADD $128, R4 // bump up to next 128 bytes in buffer + + BC 18, 0, first_cool_down + +cool_top: + LVX (R3), const1 // constants + ADD $16, R3 // inc to next constants + OR $0, R2, R2 + + VXOR V0, V8, V0 // xor in previous vpmsumd + VPMSUMD V16, const2, V8 // vpmsumd with constants + LVX (R4), V16 // buffer + OR $0, R2, R2 + + VXOR V1, V9, V1 // xor in previous + VPMSUMD V17, const2, V9 // vpmsumd with constants + LVX (R4+off16), V17 // next in buffer + OR $0, R2, R2 + + VXOR V2, V10, V2 // xor in previous + VPMSUMD V18, const2, V10 // vpmsumd with constants + LVX (R4+off32), V18 // next in buffer + OR $0, R2, R2 + + VXOR V3, V11, V3 // xor in previous + VPMSUMD V19, const2, V11 // vpmsumd with constants + LVX (R4+off48), V19 // next in buffer + LVX (R3), const2 // get next constant + OR $0, R2, R2 + + VXOR V4, V12, V4 // xor in previous + VPMSUMD V20, const1, V12 // vpmsumd with constants + LVX (R4+off64), V20 // next in buffer + OR $0, R2, R2 + + VXOR V5, V13, V5 // xor in previous + VPMSUMD V21, const1, V13 // vpmsumd with constants + LVX (R4+off80), V21 // next in buffer + OR $0, R2, R2 + + VXOR V6, V14, V6 // xor in previous + VPMSUMD V22, const1, V14 // vpmsumd with constants + LVX (R4+off96), V22 // next in buffer + OR $0, R2, R2 + + VXOR V7, V15, V7 // xor in previous + VPMSUMD V23, const1, V15 // vpmsumd with constants + LVX (R4+off112), V23 // next in buffer + + ADD $128, R4 // bump up buffer pointer + BDNZ cool_top // are we done? + +first_cool_down: + + // load the constants + // xor in the previous value + // vpmsumd the result with constants + + LVX (R3), const1 + ADD $16, R3 + + VXOR V0, V8, V0 + VPMSUMD V16, const1, V8 + OR $0, R2, R2 + + VXOR V1, V9, V1 + VPMSUMD V17, const1, V9 + OR $0, R2, R2 + + VXOR V2, V10, V2 + VPMSUMD V18, const1, V10 + OR $0, R2, R2 + + VXOR V3, V11, V3 + VPMSUMD V19, const1, V11 + OR $0, R2, R2 + + VXOR V4, V12, V4 + VPMSUMD V20, const1, V12 + OR $0, R2, R2 + + VXOR V5, V13, V5 + VPMSUMD V21, const1, V13 + OR $0, R2, R2 + + VXOR V6, V14, V6 + VPMSUMD V22, const1, V14 + OR $0, R2, R2 + + VXOR V7, V15, V7 + VPMSUMD V23, const1, V15 + OR $0, R2, R2 + +second_cool_down: + + VXOR V0, V8, V0 + VXOR V1, V9, V1 + VXOR V2, V10, V2 + VXOR V3, V11, V3 + VXOR V4, V12, V4 + VXOR V5, V13, V5 + VXOR V6, V14, V6 + VXOR V7, V15, V7 + +#ifdef REFLECT + VSLDOI $4, V0, zeroes, V0 + VSLDOI $4, V1, zeroes, V1 + VSLDOI $4, V2, zeroes, V2 + VSLDOI $4, V3, zeroes, V3 + VSLDOI $4, V4, zeroes, V4 + VSLDOI $4, V5, zeroes, V5 + VSLDOI $4, V6, zeroes, V6 + VSLDOI $4, V7, zeroes, V7 + +#endif + + LVX (R4), V8 + LVX (R4+off16), V9 + LVX (R4+off32), V10 + LVX (R4+off48), V11 + LVX (R4+off64), V12 + LVX (R4+off80), V13 + LVX (R4+off96), V14 + LVX (R4+off112), V15 + + ADD $128, R4 + + VXOR V0, V8, V16 + VXOR V1, V9, V17 + VXOR V2, V10, V18 + VXOR V3, V11, V19 + VXOR V4, V12, V20 + VXOR V5, V13, V21 + VXOR V6, V14, V22 + VXOR V7, V15, V23 + + MOVD $1, R15 + CMP $0, R6 + ADD $128, R6 + + BNE l1 + ANDCC $127, R5 + SUBC R5, $128, R6 + ADD R3, R6, R3 + + SRD $4, R5, R7 + MOVD R7, CTR + LVX (R3), V0 + LVX (R3+off16), V1 + LVX (R3+off32), V2 + LVX (R3+off48), V3 + LVX (R3+off64), V4 + LVX (R3+off80), V5 + LVX (R3+off96), V6 + LVX (R3+off112), V7 + + ADD $128, R3 + + VPMSUMW V16, V0, V0 + VPMSUMW V17, V1, V1 + VPMSUMW V18, V2, V2 + VPMSUMW V19, V3, V3 + VPMSUMW V20, V4, V4 + VPMSUMW V21, V5, V5 + VPMSUMW V22, V6, V6 + VPMSUMW V23, V7, V7 + + // now reduce the tail + + CMP $0, R7 + BEQ next1 + + LVX (R4), V16 + LVX (R3), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + BC 18, 0, next1 + + LVX (R4+off16), V16 + LVX (R3+off16), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + BC 18, 0, next1 + + LVX (R4+off32), V16 + LVX (R3+off32), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + BC 18, 0, next1 + + LVX (R4+off48), V16 + LVX (R3+off48), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + BC 18, 0, next1 + + LVX (R4+off64), V16 + LVX (R3+off64), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + BC 18, 0, next1 + + LVX (R4+off80), V16 + LVX (R3+off80), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + BC 18, 0, next1 + + LVX (R4+off96), V16 + LVX (R3+off96), V17 + VPMSUMW V16, V17, V16 + VXOR V0, V16, V0 + +next1: + VXOR V0, V1, V0 + VXOR V2, V3, V2 + VXOR V4, V5, V4 + VXOR V6, V7, V6 + VXOR V0, V2, V0 + VXOR V4, V6, V4 + VXOR V0, V4, V0 + +barrett_reduction: + + CMP R14, $1 + BNE barcstTable + MOVD $·IEEEBarConst(SB), R3 + BR startbarConst + +barcstTable: + MOVD $·CastBarConst(SB), R3 + +startbarConst: + LVX (R3), const1 + LVX (R3+off16), const2 + + VSLDOI $8, V0, V0, V1 + VXOR V0, V1, V0 + +#ifdef REFLECT + VSPLTISB $1, V1 + VSL V0, V1, V0 + +#endif + + VAND V0, mask_64bit, V0 + +#ifndef REFLECT + + VPMSUMD V0, const1, V1 + VSLDOI $8, zeroes, V1, V1 + VPMSUMD V1, const2, V1 + VXOR V0, V1, V0 + VSLDOI $8, V0, zeroes, V0 + +#else + + VAND V0, mask_32bit, V1 + VPMSUMD V1, const1, V1 + VAND V1, mask_32bit, V1 + VPMSUMD V1, const2, V1 + VXOR V0, V1, V0 + VSLDOI $4, V0, zeroes, V0 + +#endif + + MFVSRD VS32, R3 // VS32 = V0 + + NOR R3, R3, R3 // return ^crc + MOVW R3, ret+32(FP) + RET + +first_warm_up_done: + + LVX (R3), const1 + ADD $16, R3 + + VPMSUMD V16, const1, V8 + VPMSUMD V17, const1, V9 + VPMSUMD V18, const1, V10 + VPMSUMD V19, const1, V11 + VPMSUMD V20, const1, V12 + VPMSUMD V21, const1, V13 + VPMSUMD V22, const1, V14 + VPMSUMD V23, const1, V15 + + BR second_cool_down + +short: + CMP $0, R5 + BEQ zero + + // compute short constants + + CMP R14, $1 + BNE castshTable + MOVD $·IEEEConst(SB), R3 + ADD $4080, R3 + BR startshConst + +castshTable: + MOVD $·CastConst(SB), R3 + ADD $4080, R3 + +startshConst: + SUBC R5, $256, R6 // sub from 256 + ADD R3, R6, R3 + + // calculate where to start + + SRD $4, R5, R7 + MOVD R7, CTR + + VXOR V19, V19, V19 + VXOR V20, V20, V20 + + LVX (R4), V0 + LVX (R3), V16 + VXOR V0, V8, V0 + VPMSUMW V0, V16, V0 + BC 18, 0, v0 + + LVX (R4+off16), V1 + LVX (R3+off16), V17 + VPMSUMW V1, V17, V1 + BC 18, 0, v1 + + LVX (R4+off32), V2 + LVX (R3+off32), V16 + VPMSUMW V2, V16, V2 + BC 18, 0, v2 + + LVX (R4+off48), V3 + LVX (R3+off48), V17 + VPMSUMW V3, V17, V3 + BC 18, 0, v3 + + LVX (R4+off64), V4 + LVX (R3+off64), V16 + VPMSUMW V4, V16, V4 + BC 18, 0, v4 + + LVX (R4+off80), V5 + LVX (R3+off80), V17 + VPMSUMW V5, V17, V5 + BC 18, 0, v5 + + LVX (R4+off96), V6 + LVX (R3+off96), V16 + VPMSUMW V6, V16, V6 + BC 18, 0, v6 + + LVX (R4+off112), V7 + LVX (R3+off112), V17 + VPMSUMW V7, V17, V7 + BC 18, 0, v7 + + ADD $128, R3 + ADD $128, R4 + + LVX (R4), V8 + LVX (R3), V16 + VPMSUMW V8, V16, V8 + BC 18, 0, v8 + + LVX (R4+off16), V9 + LVX (R3+off16), V17 + VPMSUMW V9, V17, V9 + BC 18, 0, v9 + + LVX (R4+off32), V10 + LVX (R3+off32), V16 + VPMSUMW V10, V16, V10 + BC 18, 0, v10 + + LVX (R4+off48), V11 + LVX (R3+off48), V17 + VPMSUMW V11, V17, V11 + BC 18, 0, v11 + + LVX (R4+off64), V12 + LVX (R3+off64), V16 + VPMSUMW V12, V16, V12 + BC 18, 0, v12 + + LVX (R4+off80), V13 + LVX (R3+off80), V17 + VPMSUMW V13, V17, V13 + BC 18, 0, v13 + + LVX (R4+off96), V14 + LVX (R3+off96), V16 + VPMSUMW V14, V16, V14 + BC 18, 0, v14 + + LVX (R4+off112), V15 + LVX (R3+off112), V17 + VPMSUMW V15, V17, V15 + + VXOR V19, V15, V19 + +v14: + VXOR V20, V14, V20 + +v13: + VXOR V19, V13, V19 + +v12: + VXOR V20, V12, V20 + +v11: + VXOR V19, V11, V19 + +v10: + VXOR V20, V10, V20 + +v9: + VXOR V19, V9, V19 + +v8: + VXOR V20, V8, V20 + +v7: + VXOR V19, V7, V19 + +v6: + VXOR V20, V6, V20 + +v5: + VXOR V19, V5, V19 + +v4: + VXOR V20, V4, V20 + +v3: + VXOR V19, V3, V19 + +v2: + VXOR V20, V2, V20 + +v1: + VXOR V19, V1, V19 + +v0: + VXOR V20, V0, V20 + + VXOR V19, V20, V0 + + BR barrett_reduction + +zero: + // This case is the original crc, so just return it + MOVW R10, ret+32(FP) + RET diff --git a/vendor/github.com/klauspost/crc32/crc32_s390x.go b/vendor/github.com/klauspost/crc32/crc32_s390x.go new file mode 100644 index 000000000..67b4ea7d9 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_s390x.go @@ -0,0 +1,91 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package crc32 + +import "golang.org/x/sys/cpu" + +const ( + vxMinLen = 64 + vxAlignMask = 15 // align to 16 bytes +) + +// hasVX reports whether the machine has the z/Architecture +// vector facility installed and enabled. +var hasVX = cpu.S390X.HasVX + +// vectorizedCastagnoli implements CRC32 using vector instructions. +// It is defined in crc32_s390x.s. +// +//go:noescape +func vectorizedCastagnoli(crc uint32, p []byte) uint32 + +// vectorizedIEEE implements CRC32 using vector instructions. +// It is defined in crc32_s390x.s. +// +//go:noescape +func vectorizedIEEE(crc uint32, p []byte) uint32 + +func archAvailableCastagnoli() bool { + return hasVX +} + +var archCastagnoliTable8 *slicing8Table + +func archInitCastagnoli() { + if !hasVX { + panic("not available") + } + // We still use slicing-by-8 for small buffers. + archCastagnoliTable8 = slicingMakeTable(Castagnoli) +} + +// archUpdateCastagnoli calculates the checksum of p using +// vectorizedCastagnoli. +func archUpdateCastagnoli(crc uint32, p []byte) uint32 { + if !hasVX { + panic("not available") + } + // Use vectorized function if data length is above threshold. + if len(p) >= vxMinLen { + aligned := len(p) & ^vxAlignMask + crc = vectorizedCastagnoli(crc, p[:aligned]) + p = p[aligned:] + } + if len(p) == 0 { + return crc + } + return slicingUpdate(crc, archCastagnoliTable8, p) +} + +func archAvailableIEEE() bool { + return hasVX +} + +var archIeeeTable8 *slicing8Table + +func archInitIEEE() { + if !hasVX { + panic("not available") + } + // We still use slicing-by-8 for small buffers. + archIeeeTable8 = slicingMakeTable(IEEE) +} + +// archUpdateIEEE calculates the checksum of p using vectorizedIEEE. +func archUpdateIEEE(crc uint32, p []byte) uint32 { + if !hasVX { + panic("not available") + } + // Use vectorized function if data length is above threshold. + if len(p) >= vxMinLen { + aligned := len(p) & ^vxAlignMask + crc = vectorizedIEEE(crc, p[:aligned]) + p = p[aligned:] + } + if len(p) == 0 { + return crc + } + return slicingUpdate(crc, archIeeeTable8, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_s390x.s b/vendor/github.com/klauspost/crc32/crc32_s390x.s new file mode 100644 index 000000000..aefda50e1 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_s390x.s @@ -0,0 +1,225 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "textflag.h" + +// Vector register range containing CRC-32 constants + +#define CONST_PERM_LE2BE V9 +#define CONST_R2R1 V10 +#define CONST_R4R3 V11 +#define CONST_R5 V12 +#define CONST_RU_POLY V13 +#define CONST_CRC_POLY V14 + +// The CRC-32 constant block contains reduction constants to fold and +// process particular chunks of the input data stream in parallel. +// +// Note that the constant definitions below are extended in order to compute +// intermediate results with a single VECTOR GALOIS FIELD MULTIPLY instruction. +// The rightmost doubleword can be 0 to prevent contribution to the result or +// can be multiplied by 1 to perform an XOR without the need for a separate +// VECTOR EXCLUSIVE OR instruction. +// +// The polynomials used are bit-reflected: +// +// IEEE: P'(x) = 0x0edb88320 +// Castagnoli: P'(x) = 0x082f63b78 + +// IEEE polynomial constants +DATA ·crclecons+0(SB)/8, $0x0F0E0D0C0B0A0908 // LE-to-BE mask +DATA ·crclecons+8(SB)/8, $0x0706050403020100 +DATA ·crclecons+16(SB)/8, $0x00000001c6e41596 // R2 +DATA ·crclecons+24(SB)/8, $0x0000000154442bd4 // R1 +DATA ·crclecons+32(SB)/8, $0x00000000ccaa009e // R4 +DATA ·crclecons+40(SB)/8, $0x00000001751997d0 // R3 +DATA ·crclecons+48(SB)/8, $0x0000000000000000 +DATA ·crclecons+56(SB)/8, $0x0000000163cd6124 // R5 +DATA ·crclecons+64(SB)/8, $0x0000000000000000 +DATA ·crclecons+72(SB)/8, $0x00000001F7011641 // u' +DATA ·crclecons+80(SB)/8, $0x0000000000000000 +DATA ·crclecons+88(SB)/8, $0x00000001DB710641 // P'(x) << 1 + +GLOBL ·crclecons(SB), RODATA, $144 + +// Castagonli Polynomial constants +DATA ·crcclecons+0(SB)/8, $0x0F0E0D0C0B0A0908 // LE-to-BE mask +DATA ·crcclecons+8(SB)/8, $0x0706050403020100 +DATA ·crcclecons+16(SB)/8, $0x000000009e4addf8 // R2 +DATA ·crcclecons+24(SB)/8, $0x00000000740eef02 // R1 +DATA ·crcclecons+32(SB)/8, $0x000000014cd00bd6 // R4 +DATA ·crcclecons+40(SB)/8, $0x00000000f20c0dfe // R3 +DATA ·crcclecons+48(SB)/8, $0x0000000000000000 +DATA ·crcclecons+56(SB)/8, $0x00000000dd45aab8 // R5 +DATA ·crcclecons+64(SB)/8, $0x0000000000000000 +DATA ·crcclecons+72(SB)/8, $0x00000000dea713f1 // u' +DATA ·crcclecons+80(SB)/8, $0x0000000000000000 +DATA ·crcclecons+88(SB)/8, $0x0000000105ec76f0 // P'(x) << 1 + +GLOBL ·crcclecons(SB), RODATA, $144 + +// The CRC-32 function(s) use these calling conventions: +// +// Parameters: +// +// R2: Initial CRC value, typically ~0; and final CRC (return) value. +// R3: Input buffer pointer, performance might be improved if the +// buffer is on a doubleword boundary. +// R4: Length of the buffer, must be 64 bytes or greater. +// +// Register usage: +// +// R5: CRC-32 constant pool base pointer. +// V0: Initial CRC value and intermediate constants and results. +// V1..V4: Data for CRC computation. +// V5..V8: Next data chunks that are fetched from the input buffer. +// +// V9..V14: CRC-32 constants. + +// func vectorizedIEEE(crc uint32, p []byte) uint32 +TEXT ·vectorizedIEEE(SB), NOSPLIT, $0 + MOVWZ crc+0(FP), R2 // R2 stores the CRC value + MOVD p+8(FP), R3 // data pointer + MOVD p_len+16(FP), R4 // len(p) + + MOVD $·crclecons(SB), R5 + BR vectorizedBody<>(SB) + +// func vectorizedCastagnoli(crc uint32, p []byte) uint32 +TEXT ·vectorizedCastagnoli(SB), NOSPLIT, $0 + MOVWZ crc+0(FP), R2 // R2 stores the CRC value + MOVD p+8(FP), R3 // data pointer + MOVD p_len+16(FP), R4 // len(p) + + // R5: crc-32 constant pool base pointer, constant is used to reduce crc + MOVD $·crcclecons(SB), R5 + BR vectorizedBody<>(SB) + +TEXT vectorizedBody<>(SB), NOSPLIT, $0 + XOR $0xffffffff, R2 // NOTW R2 + VLM 0(R5), CONST_PERM_LE2BE, CONST_CRC_POLY + + // Load the initial CRC value into the rightmost word of V0 + VZERO V0 + VLVGF $3, R2, V0 + + // Crash if the input size is less than 64-bytes. + CMP R4, $64 + BLT crash + + // Load a 64-byte data chunk and XOR with CRC + VLM 0(R3), V1, V4 // 64-bytes into V1..V4 + + // Reflect the data if the CRC operation is in the bit-reflected domain + VPERM V1, V1, CONST_PERM_LE2BE, V1 + VPERM V2, V2, CONST_PERM_LE2BE, V2 + VPERM V3, V3, CONST_PERM_LE2BE, V3 + VPERM V4, V4, CONST_PERM_LE2BE, V4 + + VX V0, V1, V1 // V1 ^= CRC + ADD $64, R3 // BUF = BUF + 64 + ADD $(-64), R4 + + // Check remaining buffer size and jump to proper folding method + CMP R4, $64 + BLT less_than_64bytes + +fold_64bytes_loop: + // Load the next 64-byte data chunk into V5 to V8 + VLM 0(R3), V5, V8 + VPERM V5, V5, CONST_PERM_LE2BE, V5 + VPERM V6, V6, CONST_PERM_LE2BE, V6 + VPERM V7, V7, CONST_PERM_LE2BE, V7 + VPERM V8, V8, CONST_PERM_LE2BE, V8 + + // Perform a GF(2) multiplication of the doublewords in V1 with + // the reduction constants in V0. The intermediate result is + // then folded (accumulated) with the next data chunk in V5 and + // stored in V1. Repeat this step for the register contents + // in V2, V3, and V4 respectively. + + VGFMAG CONST_R2R1, V1, V5, V1 + VGFMAG CONST_R2R1, V2, V6, V2 + VGFMAG CONST_R2R1, V3, V7, V3 + VGFMAG CONST_R2R1, V4, V8, V4 + + // Adjust buffer pointer and length for next loop + ADD $64, R3 // BUF = BUF + 64 + ADD $(-64), R4 // LEN = LEN - 64 + + CMP R4, $64 + BGE fold_64bytes_loop + +less_than_64bytes: + // Fold V1 to V4 into a single 128-bit value in V1 + VGFMAG CONST_R4R3, V1, V2, V1 + VGFMAG CONST_R4R3, V1, V3, V1 + VGFMAG CONST_R4R3, V1, V4, V1 + + // Check whether to continue with 64-bit folding + CMP R4, $16 + BLT final_fold + +fold_16bytes_loop: + VL 0(R3), V2 // Load next data chunk + VPERM V2, V2, CONST_PERM_LE2BE, V2 + + VGFMAG CONST_R4R3, V1, V2, V1 // Fold next data chunk + + // Adjust buffer pointer and size for folding next data chunk + ADD $16, R3 + ADD $-16, R4 + + // Process remaining data chunks + CMP R4, $16 + BGE fold_16bytes_loop + +final_fold: + VLEIB $7, $0x40, V9 + VSRLB V9, CONST_R4R3, V0 + VLEIG $0, $1, V0 + + VGFMG V0, V1, V1 + + VLEIB $7, $0x20, V9 // Shift by words + VSRLB V9, V1, V2 // Store remaining bits in V2 + VUPLLF V1, V1 // Split rightmost doubleword + VGFMAG CONST_R5, V1, V2, V1 // V1 = (V1 * R5) XOR V2 + + // The input values to the Barret reduction are the degree-63 polynomial + // in V1 (R(x)), degree-32 generator polynomial, and the reduction + // constant u. The Barret reduction result is the CRC value of R(x) mod + // P(x). + // + // The Barret reduction algorithm is defined as: + // + // 1. T1(x) = floor( R(x) / x^32 ) GF2MUL u + // 2. T2(x) = floor( T1(x) / x^32 ) GF2MUL P(x) + // 3. C(x) = R(x) XOR T2(x) mod x^32 + // + // Note: To compensate the division by x^32, use the vector unpack + // instruction to move the leftmost word into the leftmost doubleword + // of the vector register. The rightmost doubleword is multiplied + // with zero to not contribute to the intermediate results. + + // T1(x) = floor( R(x) / x^32 ) GF2MUL u + VUPLLF V1, V2 + VGFMG CONST_RU_POLY, V2, V2 + + // Compute the GF(2) product of the CRC polynomial in VO with T1(x) in + // V2 and XOR the intermediate result, T2(x), with the value in V1. + // The final result is in the rightmost word of V2. + + VUPLLF V2, V2 + VGFMAG CONST_CRC_POLY, V2, V1, V2 + +done: + VLGVF $2, V2, R2 + XOR $0xffffffff, R2 // NOTW R2 + MOVWZ R2, ret + 32(FP) + RET + +crash: + MOVD $0, (R0) // input size is less than 64-bytes + diff --git a/vendor/github.com/klauspost/crc32/crc32_table_ppc64le.s b/vendor/github.com/klauspost/crc32/crc32_table_ppc64le.s new file mode 100644 index 000000000..1f3c1efda --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_table_ppc64le.s @@ -0,0 +1,3285 @@ +// Code generated by "go run gen_const_ppc64le.go"; DO NOT EDIT. + +#include "textflag.h" + +// Reduce 262144 kbits to 1024 bits +// x^261184 mod p(x), x^261120 mod p(x) +DATA ·IEEEConst+0(SB)/8, $0x0000000099ea94a8 +DATA ·IEEEConst+8(SB)/8, $0x00000001651797d2 + +// x^260160 mod p(x), x^260096 mod p(x) +DATA ·IEEEConst+16(SB)/8, $0x00000000945a8420 +DATA ·IEEEConst+24(SB)/8, $0x0000000021e0d56c + +// x^259136 mod p(x), x^259072 mod p(x) +DATA ·IEEEConst+32(SB)/8, $0x0000000030762706 +DATA ·IEEEConst+40(SB)/8, $0x000000000f95ecaa + +// x^258112 mod p(x), x^258048 mod p(x) +DATA ·IEEEConst+48(SB)/8, $0x00000001a52fc582 +DATA ·IEEEConst+56(SB)/8, $0x00000001ebd224ac + +// x^257088 mod p(x), x^257024 mod p(x) +DATA ·IEEEConst+64(SB)/8, $0x00000001a4a7167a +DATA ·IEEEConst+72(SB)/8, $0x000000000ccb97ca + +// x^256064 mod p(x), x^256000 mod p(x) +DATA ·IEEEConst+80(SB)/8, $0x000000000c18249a +DATA ·IEEEConst+88(SB)/8, $0x00000001006ec8a8 + +// x^255040 mod p(x), x^254976 mod p(x) +DATA ·IEEEConst+96(SB)/8, $0x00000000a924ae7c +DATA ·IEEEConst+104(SB)/8, $0x000000014f58f196 + +// x^254016 mod p(x), x^253952 mod p(x) +DATA ·IEEEConst+112(SB)/8, $0x00000001e12ccc12 +DATA ·IEEEConst+120(SB)/8, $0x00000001a7192ca6 + +// x^252992 mod p(x), x^252928 mod p(x) +DATA ·IEEEConst+128(SB)/8, $0x00000000a0b9d4ac +DATA ·IEEEConst+136(SB)/8, $0x000000019a64bab2 + +// x^251968 mod p(x), x^251904 mod p(x) +DATA ·IEEEConst+144(SB)/8, $0x0000000095e8ddfe +DATA ·IEEEConst+152(SB)/8, $0x0000000014f4ed2e + +// x^250944 mod p(x), x^250880 mod p(x) +DATA ·IEEEConst+160(SB)/8, $0x00000000233fddc4 +DATA ·IEEEConst+168(SB)/8, $0x000000011092b6a2 + +// x^249920 mod p(x), x^249856 mod p(x) +DATA ·IEEEConst+176(SB)/8, $0x00000001b4529b62 +DATA ·IEEEConst+184(SB)/8, $0x00000000c8a1629c + +// x^248896 mod p(x), x^248832 mod p(x) +DATA ·IEEEConst+192(SB)/8, $0x00000001a7fa0e64 +DATA ·IEEEConst+200(SB)/8, $0x000000017bf32e8e + +// x^247872 mod p(x), x^247808 mod p(x) +DATA ·IEEEConst+208(SB)/8, $0x00000001b5334592 +DATA ·IEEEConst+216(SB)/8, $0x00000001f8cc6582 + +// x^246848 mod p(x), x^246784 mod p(x) +DATA ·IEEEConst+224(SB)/8, $0x000000011f8ee1b4 +DATA ·IEEEConst+232(SB)/8, $0x000000008631ddf0 + +// x^245824 mod p(x), x^245760 mod p(x) +DATA ·IEEEConst+240(SB)/8, $0x000000006252e632 +DATA ·IEEEConst+248(SB)/8, $0x000000007e5a76d0 + +// x^244800 mod p(x), x^244736 mod p(x) +DATA ·IEEEConst+256(SB)/8, $0x00000000ab973e84 +DATA ·IEEEConst+264(SB)/8, $0x000000002b09b31c + +// x^243776 mod p(x), x^243712 mod p(x) +DATA ·IEEEConst+272(SB)/8, $0x000000007734f5ec +DATA ·IEEEConst+280(SB)/8, $0x00000001b2df1f84 + +// x^242752 mod p(x), x^242688 mod p(x) +DATA ·IEEEConst+288(SB)/8, $0x000000007c547798 +DATA ·IEEEConst+296(SB)/8, $0x00000001d6f56afc + +// x^241728 mod p(x), x^241664 mod p(x) +DATA ·IEEEConst+304(SB)/8, $0x000000007ec40210 +DATA ·IEEEConst+312(SB)/8, $0x00000001b9b5e70c + +// x^240704 mod p(x), x^240640 mod p(x) +DATA ·IEEEConst+320(SB)/8, $0x00000001ab1695a8 +DATA ·IEEEConst+328(SB)/8, $0x0000000034b626d2 + +// x^239680 mod p(x), x^239616 mod p(x) +DATA ·IEEEConst+336(SB)/8, $0x0000000090494bba +DATA ·IEEEConst+344(SB)/8, $0x000000014c53479a + +// x^238656 mod p(x), x^238592 mod p(x) +DATA ·IEEEConst+352(SB)/8, $0x00000001123fb816 +DATA ·IEEEConst+360(SB)/8, $0x00000001a6d179a4 + +// x^237632 mod p(x), x^237568 mod p(x) +DATA ·IEEEConst+368(SB)/8, $0x00000001e188c74c +DATA ·IEEEConst+376(SB)/8, $0x000000015abd16b4 + +// x^236608 mod p(x), x^236544 mod p(x) +DATA ·IEEEConst+384(SB)/8, $0x00000001c2d3451c +DATA ·IEEEConst+392(SB)/8, $0x00000000018f9852 + +// x^235584 mod p(x), x^235520 mod p(x) +DATA ·IEEEConst+400(SB)/8, $0x00000000f55cf1ca +DATA ·IEEEConst+408(SB)/8, $0x000000001fb3084a + +// x^234560 mod p(x), x^234496 mod p(x) +DATA ·IEEEConst+416(SB)/8, $0x00000001a0531540 +DATA ·IEEEConst+424(SB)/8, $0x00000000c53dfb04 + +// x^233536 mod p(x), x^233472 mod p(x) +DATA ·IEEEConst+432(SB)/8, $0x0000000132cd7ebc +DATA ·IEEEConst+440(SB)/8, $0x00000000e10c9ad6 + +// x^232512 mod p(x), x^232448 mod p(x) +DATA ·IEEEConst+448(SB)/8, $0x0000000073ab7f36 +DATA ·IEEEConst+456(SB)/8, $0x0000000025aa994a + +// x^231488 mod p(x), x^231424 mod p(x) +DATA ·IEEEConst+464(SB)/8, $0x0000000041aed1c2 +DATA ·IEEEConst+472(SB)/8, $0x00000000fa3a74c4 + +// x^230464 mod p(x), x^230400 mod p(x) +DATA ·IEEEConst+480(SB)/8, $0x0000000136c53800 +DATA ·IEEEConst+488(SB)/8, $0x0000000033eb3f40 + +// x^229440 mod p(x), x^229376 mod p(x) +DATA ·IEEEConst+496(SB)/8, $0x0000000126835a30 +DATA ·IEEEConst+504(SB)/8, $0x000000017193f296 + +// x^228416 mod p(x), x^228352 mod p(x) +DATA ·IEEEConst+512(SB)/8, $0x000000006241b502 +DATA ·IEEEConst+520(SB)/8, $0x0000000043f6c86a + +// x^227392 mod p(x), x^227328 mod p(x) +DATA ·IEEEConst+528(SB)/8, $0x00000000d5196ad4 +DATA ·IEEEConst+536(SB)/8, $0x000000016b513ec6 + +// x^226368 mod p(x), x^226304 mod p(x) +DATA ·IEEEConst+544(SB)/8, $0x000000009cfa769a +DATA ·IEEEConst+552(SB)/8, $0x00000000c8f25b4e + +// x^225344 mod p(x), x^225280 mod p(x) +DATA ·IEEEConst+560(SB)/8, $0x00000000920e5df4 +DATA ·IEEEConst+568(SB)/8, $0x00000001a45048ec + +// x^224320 mod p(x), x^224256 mod p(x) +DATA ·IEEEConst+576(SB)/8, $0x0000000169dc310e +DATA ·IEEEConst+584(SB)/8, $0x000000000c441004 + +// x^223296 mod p(x), x^223232 mod p(x) +DATA ·IEEEConst+592(SB)/8, $0x0000000009fc331c +DATA ·IEEEConst+600(SB)/8, $0x000000000e17cad6 + +// x^222272 mod p(x), x^222208 mod p(x) +DATA ·IEEEConst+608(SB)/8, $0x000000010d94a81e +DATA ·IEEEConst+616(SB)/8, $0x00000001253ae964 + +// x^221248 mod p(x), x^221184 mod p(x) +DATA ·IEEEConst+624(SB)/8, $0x0000000027a20ab2 +DATA ·IEEEConst+632(SB)/8, $0x00000001d7c88ebc + +// x^220224 mod p(x), x^220160 mod p(x) +DATA ·IEEEConst+640(SB)/8, $0x0000000114f87504 +DATA ·IEEEConst+648(SB)/8, $0x00000001e7ca913a + +// x^219200 mod p(x), x^219136 mod p(x) +DATA ·IEEEConst+656(SB)/8, $0x000000004b076d96 +DATA ·IEEEConst+664(SB)/8, $0x0000000033ed078a + +// x^218176 mod p(x), x^218112 mod p(x) +DATA ·IEEEConst+672(SB)/8, $0x00000000da4d1e74 +DATA ·IEEEConst+680(SB)/8, $0x00000000e1839c78 + +// x^217152 mod p(x), x^217088 mod p(x) +DATA ·IEEEConst+688(SB)/8, $0x000000001b81f672 +DATA ·IEEEConst+696(SB)/8, $0x00000001322b267e + +// x^216128 mod p(x), x^216064 mod p(x) +DATA ·IEEEConst+704(SB)/8, $0x000000009367c988 +DATA ·IEEEConst+712(SB)/8, $0x00000000638231b6 + +// x^215104 mod p(x), x^215040 mod p(x) +DATA ·IEEEConst+720(SB)/8, $0x00000001717214ca +DATA ·IEEEConst+728(SB)/8, $0x00000001ee7f16f4 + +// x^214080 mod p(x), x^214016 mod p(x) +DATA ·IEEEConst+736(SB)/8, $0x000000009f47d820 +DATA ·IEEEConst+744(SB)/8, $0x0000000117d9924a + +// x^213056 mod p(x), x^212992 mod p(x) +DATA ·IEEEConst+752(SB)/8, $0x000000010d9a47d2 +DATA ·IEEEConst+760(SB)/8, $0x00000000e1a9e0c4 + +// x^212032 mod p(x), x^211968 mod p(x) +DATA ·IEEEConst+768(SB)/8, $0x00000000a696c58c +DATA ·IEEEConst+776(SB)/8, $0x00000001403731dc + +// x^211008 mod p(x), x^210944 mod p(x) +DATA ·IEEEConst+784(SB)/8, $0x000000002aa28ec6 +DATA ·IEEEConst+792(SB)/8, $0x00000001a5ea9682 + +// x^209984 mod p(x), x^209920 mod p(x) +DATA ·IEEEConst+800(SB)/8, $0x00000001fe18fd9a +DATA ·IEEEConst+808(SB)/8, $0x0000000101c5c578 + +// x^208960 mod p(x), x^208896 mod p(x) +DATA ·IEEEConst+816(SB)/8, $0x000000019d4fc1ae +DATA ·IEEEConst+824(SB)/8, $0x00000000dddf6494 + +// x^207936 mod p(x), x^207872 mod p(x) +DATA ·IEEEConst+832(SB)/8, $0x00000001ba0e3dea +DATA ·IEEEConst+840(SB)/8, $0x00000000f1c3db28 + +// x^206912 mod p(x), x^206848 mod p(x) +DATA ·IEEEConst+848(SB)/8, $0x0000000074b59a5e +DATA ·IEEEConst+856(SB)/8, $0x000000013112fb9c + +// x^205888 mod p(x), x^205824 mod p(x) +DATA ·IEEEConst+864(SB)/8, $0x00000000f2b5ea98 +DATA ·IEEEConst+872(SB)/8, $0x00000000b680b906 + +// x^204864 mod p(x), x^204800 mod p(x) +DATA ·IEEEConst+880(SB)/8, $0x0000000187132676 +DATA ·IEEEConst+888(SB)/8, $0x000000001a282932 + +// x^203840 mod p(x), x^203776 mod p(x) +DATA ·IEEEConst+896(SB)/8, $0x000000010a8c6ad4 +DATA ·IEEEConst+904(SB)/8, $0x0000000089406e7e + +// x^202816 mod p(x), x^202752 mod p(x) +DATA ·IEEEConst+912(SB)/8, $0x00000001e21dfe70 +DATA ·IEEEConst+920(SB)/8, $0x00000001def6be8c + +// x^201792 mod p(x), x^201728 mod p(x) +DATA ·IEEEConst+928(SB)/8, $0x00000001da0050e4 +DATA ·IEEEConst+936(SB)/8, $0x0000000075258728 + +// x^200768 mod p(x), x^200704 mod p(x) +DATA ·IEEEConst+944(SB)/8, $0x00000000772172ae +DATA ·IEEEConst+952(SB)/8, $0x000000019536090a + +// x^199744 mod p(x), x^199680 mod p(x) +DATA ·IEEEConst+960(SB)/8, $0x00000000e47724aa +DATA ·IEEEConst+968(SB)/8, $0x00000000f2455bfc + +// x^198720 mod p(x), x^198656 mod p(x) +DATA ·IEEEConst+976(SB)/8, $0x000000003cd63ac4 +DATA ·IEEEConst+984(SB)/8, $0x000000018c40baf4 + +// x^197696 mod p(x), x^197632 mod p(x) +DATA ·IEEEConst+992(SB)/8, $0x00000001bf47d352 +DATA ·IEEEConst+1000(SB)/8, $0x000000004cd390d4 + +// x^196672 mod p(x), x^196608 mod p(x) +DATA ·IEEEConst+1008(SB)/8, $0x000000018dc1d708 +DATA ·IEEEConst+1016(SB)/8, $0x00000001e4ece95a + +// x^195648 mod p(x), x^195584 mod p(x) +DATA ·IEEEConst+1024(SB)/8, $0x000000002d4620a4 +DATA ·IEEEConst+1032(SB)/8, $0x000000001a3ee918 + +// x^194624 mod p(x), x^194560 mod p(x) +DATA ·IEEEConst+1040(SB)/8, $0x0000000058fd1740 +DATA ·IEEEConst+1048(SB)/8, $0x000000007c652fb8 + +// x^193600 mod p(x), x^193536 mod p(x) +DATA ·IEEEConst+1056(SB)/8, $0x00000000dadd9bfc +DATA ·IEEEConst+1064(SB)/8, $0x000000011c67842c + +// x^192576 mod p(x), x^192512 mod p(x) +DATA ·IEEEConst+1072(SB)/8, $0x00000001ea2140be +DATA ·IEEEConst+1080(SB)/8, $0x00000000254f759c + +// x^191552 mod p(x), x^191488 mod p(x) +DATA ·IEEEConst+1088(SB)/8, $0x000000009de128ba +DATA ·IEEEConst+1096(SB)/8, $0x000000007ece94ca + +// x^190528 mod p(x), x^190464 mod p(x) +DATA ·IEEEConst+1104(SB)/8, $0x000000013ac3aa8e +DATA ·IEEEConst+1112(SB)/8, $0x0000000038f258c2 + +// x^189504 mod p(x), x^189440 mod p(x) +DATA ·IEEEConst+1120(SB)/8, $0x0000000099980562 +DATA ·IEEEConst+1128(SB)/8, $0x00000001cdf17b00 + +// x^188480 mod p(x), x^188416 mod p(x) +DATA ·IEEEConst+1136(SB)/8, $0x00000001c1579c86 +DATA ·IEEEConst+1144(SB)/8, $0x000000011f882c16 + +// x^187456 mod p(x), x^187392 mod p(x) +DATA ·IEEEConst+1152(SB)/8, $0x0000000068dbbf94 +DATA ·IEEEConst+1160(SB)/8, $0x0000000100093fc8 + +// x^186432 mod p(x), x^186368 mod p(x) +DATA ·IEEEConst+1168(SB)/8, $0x000000004509fb04 +DATA ·IEEEConst+1176(SB)/8, $0x00000001cd684f16 + +// x^185408 mod p(x), x^185344 mod p(x) +DATA ·IEEEConst+1184(SB)/8, $0x00000001202f6398 +DATA ·IEEEConst+1192(SB)/8, $0x000000004bc6a70a + +// x^184384 mod p(x), x^184320 mod p(x) +DATA ·IEEEConst+1200(SB)/8, $0x000000013aea243e +DATA ·IEEEConst+1208(SB)/8, $0x000000004fc7e8e4 + +// x^183360 mod p(x), x^183296 mod p(x) +DATA ·IEEEConst+1216(SB)/8, $0x00000001b4052ae6 +DATA ·IEEEConst+1224(SB)/8, $0x0000000130103f1c + +// x^182336 mod p(x), x^182272 mod p(x) +DATA ·IEEEConst+1232(SB)/8, $0x00000001cd2a0ae8 +DATA ·IEEEConst+1240(SB)/8, $0x0000000111b0024c + +// x^181312 mod p(x), x^181248 mod p(x) +DATA ·IEEEConst+1248(SB)/8, $0x00000001fe4aa8b4 +DATA ·IEEEConst+1256(SB)/8, $0x000000010b3079da + +// x^180288 mod p(x), x^180224 mod p(x) +DATA ·IEEEConst+1264(SB)/8, $0x00000001d1559a42 +DATA ·IEEEConst+1272(SB)/8, $0x000000010192bcc2 + +// x^179264 mod p(x), x^179200 mod p(x) +DATA ·IEEEConst+1280(SB)/8, $0x00000001f3e05ecc +DATA ·IEEEConst+1288(SB)/8, $0x0000000074838d50 + +// x^178240 mod p(x), x^178176 mod p(x) +DATA ·IEEEConst+1296(SB)/8, $0x0000000104ddd2cc +DATA ·IEEEConst+1304(SB)/8, $0x000000001b20f520 + +// x^177216 mod p(x), x^177152 mod p(x) +DATA ·IEEEConst+1312(SB)/8, $0x000000015393153c +DATA ·IEEEConst+1320(SB)/8, $0x0000000050c3590a + +// x^176192 mod p(x), x^176128 mod p(x) +DATA ·IEEEConst+1328(SB)/8, $0x0000000057e942c6 +DATA ·IEEEConst+1336(SB)/8, $0x00000000b41cac8e + +// x^175168 mod p(x), x^175104 mod p(x) +DATA ·IEEEConst+1344(SB)/8, $0x000000012c633850 +DATA ·IEEEConst+1352(SB)/8, $0x000000000c72cc78 + +// x^174144 mod p(x), x^174080 mod p(x) +DATA ·IEEEConst+1360(SB)/8, $0x00000000ebcaae4c +DATA ·IEEEConst+1368(SB)/8, $0x0000000030cdb032 + +// x^173120 mod p(x), x^173056 mod p(x) +DATA ·IEEEConst+1376(SB)/8, $0x000000013ee532a6 +DATA ·IEEEConst+1384(SB)/8, $0x000000013e09fc32 + +// x^172096 mod p(x), x^172032 mod p(x) +DATA ·IEEEConst+1392(SB)/8, $0x00000001bf0cbc7e +DATA ·IEEEConst+1400(SB)/8, $0x000000001ed624d2 + +// x^171072 mod p(x), x^171008 mod p(x) +DATA ·IEEEConst+1408(SB)/8, $0x00000000d50b7a5a +DATA ·IEEEConst+1416(SB)/8, $0x00000000781aee1a + +// x^170048 mod p(x), x^169984 mod p(x) +DATA ·IEEEConst+1424(SB)/8, $0x0000000002fca6e8 +DATA ·IEEEConst+1432(SB)/8, $0x00000001c4d8348c + +// x^169024 mod p(x), x^168960 mod p(x) +DATA ·IEEEConst+1440(SB)/8, $0x000000007af40044 +DATA ·IEEEConst+1448(SB)/8, $0x0000000057a40336 + +// x^168000 mod p(x), x^167936 mod p(x) +DATA ·IEEEConst+1456(SB)/8, $0x0000000016178744 +DATA ·IEEEConst+1464(SB)/8, $0x0000000085544940 + +// x^166976 mod p(x), x^166912 mod p(x) +DATA ·IEEEConst+1472(SB)/8, $0x000000014c177458 +DATA ·IEEEConst+1480(SB)/8, $0x000000019cd21e80 + +// x^165952 mod p(x), x^165888 mod p(x) +DATA ·IEEEConst+1488(SB)/8, $0x000000011b6ddf04 +DATA ·IEEEConst+1496(SB)/8, $0x000000013eb95bc0 + +// x^164928 mod p(x), x^164864 mod p(x) +DATA ·IEEEConst+1504(SB)/8, $0x00000001f3e29ccc +DATA ·IEEEConst+1512(SB)/8, $0x00000001dfc9fdfc + +// x^163904 mod p(x), x^163840 mod p(x) +DATA ·IEEEConst+1520(SB)/8, $0x0000000135ae7562 +DATA ·IEEEConst+1528(SB)/8, $0x00000000cd028bc2 + +// x^162880 mod p(x), x^162816 mod p(x) +DATA ·IEEEConst+1536(SB)/8, $0x0000000190ef812c +DATA ·IEEEConst+1544(SB)/8, $0x0000000090db8c44 + +// x^161856 mod p(x), x^161792 mod p(x) +DATA ·IEEEConst+1552(SB)/8, $0x0000000067a2c786 +DATA ·IEEEConst+1560(SB)/8, $0x000000010010a4ce + +// x^160832 mod p(x), x^160768 mod p(x) +DATA ·IEEEConst+1568(SB)/8, $0x0000000048b9496c +DATA ·IEEEConst+1576(SB)/8, $0x00000001c8f4c72c + +// x^159808 mod p(x), x^159744 mod p(x) +DATA ·IEEEConst+1584(SB)/8, $0x000000015a422de6 +DATA ·IEEEConst+1592(SB)/8, $0x000000001c26170c + +// x^158784 mod p(x), x^158720 mod p(x) +DATA ·IEEEConst+1600(SB)/8, $0x00000001ef0e3640 +DATA ·IEEEConst+1608(SB)/8, $0x00000000e3fccf68 + +// x^157760 mod p(x), x^157696 mod p(x) +DATA ·IEEEConst+1616(SB)/8, $0x00000001006d2d26 +DATA ·IEEEConst+1624(SB)/8, $0x00000000d513ed24 + +// x^156736 mod p(x), x^156672 mod p(x) +DATA ·IEEEConst+1632(SB)/8, $0x00000001170d56d6 +DATA ·IEEEConst+1640(SB)/8, $0x00000000141beada + +// x^155712 mod p(x), x^155648 mod p(x) +DATA ·IEEEConst+1648(SB)/8, $0x00000000a5fb613c +DATA ·IEEEConst+1656(SB)/8, $0x000000011071aea0 + +// x^154688 mod p(x), x^154624 mod p(x) +DATA ·IEEEConst+1664(SB)/8, $0x0000000040bbf7fc +DATA ·IEEEConst+1672(SB)/8, $0x000000012e19080a + +// x^153664 mod p(x), x^153600 mod p(x) +DATA ·IEEEConst+1680(SB)/8, $0x000000016ac3a5b2 +DATA ·IEEEConst+1688(SB)/8, $0x0000000100ecf826 + +// x^152640 mod p(x), x^152576 mod p(x) +DATA ·IEEEConst+1696(SB)/8, $0x00000000abf16230 +DATA ·IEEEConst+1704(SB)/8, $0x0000000069b09412 + +// x^151616 mod p(x), x^151552 mod p(x) +DATA ·IEEEConst+1712(SB)/8, $0x00000001ebe23fac +DATA ·IEEEConst+1720(SB)/8, $0x0000000122297bac + +// x^150592 mod p(x), x^150528 mod p(x) +DATA ·IEEEConst+1728(SB)/8, $0x000000008b6a0894 +DATA ·IEEEConst+1736(SB)/8, $0x00000000e9e4b068 + +// x^149568 mod p(x), x^149504 mod p(x) +DATA ·IEEEConst+1744(SB)/8, $0x00000001288ea478 +DATA ·IEEEConst+1752(SB)/8, $0x000000004b38651a + +// x^148544 mod p(x), x^148480 mod p(x) +DATA ·IEEEConst+1760(SB)/8, $0x000000016619c442 +DATA ·IEEEConst+1768(SB)/8, $0x00000001468360e2 + +// x^147520 mod p(x), x^147456 mod p(x) +DATA ·IEEEConst+1776(SB)/8, $0x0000000086230038 +DATA ·IEEEConst+1784(SB)/8, $0x00000000121c2408 + +// x^146496 mod p(x), x^146432 mod p(x) +DATA ·IEEEConst+1792(SB)/8, $0x000000017746a756 +DATA ·IEEEConst+1800(SB)/8, $0x00000000da7e7d08 + +// x^145472 mod p(x), x^145408 mod p(x) +DATA ·IEEEConst+1808(SB)/8, $0x0000000191b8f8f8 +DATA ·IEEEConst+1816(SB)/8, $0x00000001058d7652 + +// x^144448 mod p(x), x^144384 mod p(x) +DATA ·IEEEConst+1824(SB)/8, $0x000000008e167708 +DATA ·IEEEConst+1832(SB)/8, $0x000000014a098a90 + +// x^143424 mod p(x), x^143360 mod p(x) +DATA ·IEEEConst+1840(SB)/8, $0x0000000148b22d54 +DATA ·IEEEConst+1848(SB)/8, $0x0000000020dbe72e + +// x^142400 mod p(x), x^142336 mod p(x) +DATA ·IEEEConst+1856(SB)/8, $0x0000000044ba2c3c +DATA ·IEEEConst+1864(SB)/8, $0x000000011e7323e8 + +// x^141376 mod p(x), x^141312 mod p(x) +DATA ·IEEEConst+1872(SB)/8, $0x00000000b54d2b52 +DATA ·IEEEConst+1880(SB)/8, $0x00000000d5d4bf94 + +// x^140352 mod p(x), x^140288 mod p(x) +DATA ·IEEEConst+1888(SB)/8, $0x0000000005a4fd8a +DATA ·IEEEConst+1896(SB)/8, $0x0000000199d8746c + +// x^139328 mod p(x), x^139264 mod p(x) +DATA ·IEEEConst+1904(SB)/8, $0x0000000139f9fc46 +DATA ·IEEEConst+1912(SB)/8, $0x00000000ce9ca8a0 + +// x^138304 mod p(x), x^138240 mod p(x) +DATA ·IEEEConst+1920(SB)/8, $0x000000015a1fa824 +DATA ·IEEEConst+1928(SB)/8, $0x00000000136edece + +// x^137280 mod p(x), x^137216 mod p(x) +DATA ·IEEEConst+1936(SB)/8, $0x000000000a61ae4c +DATA ·IEEEConst+1944(SB)/8, $0x000000019b92a068 + +// x^136256 mod p(x), x^136192 mod p(x) +DATA ·IEEEConst+1952(SB)/8, $0x0000000145e9113e +DATA ·IEEEConst+1960(SB)/8, $0x0000000071d62206 + +// x^135232 mod p(x), x^135168 mod p(x) +DATA ·IEEEConst+1968(SB)/8, $0x000000006a348448 +DATA ·IEEEConst+1976(SB)/8, $0x00000000dfc50158 + +// x^134208 mod p(x), x^134144 mod p(x) +DATA ·IEEEConst+1984(SB)/8, $0x000000004d80a08c +DATA ·IEEEConst+1992(SB)/8, $0x00000001517626bc + +// x^133184 mod p(x), x^133120 mod p(x) +DATA ·IEEEConst+2000(SB)/8, $0x000000014b6837a0 +DATA ·IEEEConst+2008(SB)/8, $0x0000000148d1e4fa + +// x^132160 mod p(x), x^132096 mod p(x) +DATA ·IEEEConst+2016(SB)/8, $0x000000016896a7fc +DATA ·IEEEConst+2024(SB)/8, $0x0000000094d8266e + +// x^131136 mod p(x), x^131072 mod p(x) +DATA ·IEEEConst+2032(SB)/8, $0x000000014f187140 +DATA ·IEEEConst+2040(SB)/8, $0x00000000606c5e34 + +// x^130112 mod p(x), x^130048 mod p(x) +DATA ·IEEEConst+2048(SB)/8, $0x000000019581b9da +DATA ·IEEEConst+2056(SB)/8, $0x000000019766beaa + +// x^129088 mod p(x), x^129024 mod p(x) +DATA ·IEEEConst+2064(SB)/8, $0x00000001091bc984 +DATA ·IEEEConst+2072(SB)/8, $0x00000001d80c506c + +// x^128064 mod p(x), x^128000 mod p(x) +DATA ·IEEEConst+2080(SB)/8, $0x000000001067223c +DATA ·IEEEConst+2088(SB)/8, $0x000000001e73837c + +// x^127040 mod p(x), x^126976 mod p(x) +DATA ·IEEEConst+2096(SB)/8, $0x00000001ab16ea02 +DATA ·IEEEConst+2104(SB)/8, $0x0000000064d587de + +// x^126016 mod p(x), x^125952 mod p(x) +DATA ·IEEEConst+2112(SB)/8, $0x000000013c4598a8 +DATA ·IEEEConst+2120(SB)/8, $0x00000000f4a507b0 + +// x^124992 mod p(x), x^124928 mod p(x) +DATA ·IEEEConst+2128(SB)/8, $0x00000000b3735430 +DATA ·IEEEConst+2136(SB)/8, $0x0000000040e342fc + +// x^123968 mod p(x), x^123904 mod p(x) +DATA ·IEEEConst+2144(SB)/8, $0x00000001bb3fc0c0 +DATA ·IEEEConst+2152(SB)/8, $0x00000001d5ad9c3a + +// x^122944 mod p(x), x^122880 mod p(x) +DATA ·IEEEConst+2160(SB)/8, $0x00000001570ae19c +DATA ·IEEEConst+2168(SB)/8, $0x0000000094a691a4 + +// x^121920 mod p(x), x^121856 mod p(x) +DATA ·IEEEConst+2176(SB)/8, $0x00000001ea910712 +DATA ·IEEEConst+2184(SB)/8, $0x00000001271ecdfa + +// x^120896 mod p(x), x^120832 mod p(x) +DATA ·IEEEConst+2192(SB)/8, $0x0000000167127128 +DATA ·IEEEConst+2200(SB)/8, $0x000000009e54475a + +// x^119872 mod p(x), x^119808 mod p(x) +DATA ·IEEEConst+2208(SB)/8, $0x0000000019e790a2 +DATA ·IEEEConst+2216(SB)/8, $0x00000000c9c099ee + +// x^118848 mod p(x), x^118784 mod p(x) +DATA ·IEEEConst+2224(SB)/8, $0x000000003788f710 +DATA ·IEEEConst+2232(SB)/8, $0x000000009a2f736c + +// x^117824 mod p(x), x^117760 mod p(x) +DATA ·IEEEConst+2240(SB)/8, $0x00000001682a160e +DATA ·IEEEConst+2248(SB)/8, $0x00000000bb9f4996 + +// x^116800 mod p(x), x^116736 mod p(x) +DATA ·IEEEConst+2256(SB)/8, $0x000000007f0ebd2e +DATA ·IEEEConst+2264(SB)/8, $0x00000001db688050 + +// x^115776 mod p(x), x^115712 mod p(x) +DATA ·IEEEConst+2272(SB)/8, $0x000000002b032080 +DATA ·IEEEConst+2280(SB)/8, $0x00000000e9b10af4 + +// x^114752 mod p(x), x^114688 mod p(x) +DATA ·IEEEConst+2288(SB)/8, $0x00000000cfd1664a +DATA ·IEEEConst+2296(SB)/8, $0x000000012d4545e4 + +// x^113728 mod p(x), x^113664 mod p(x) +DATA ·IEEEConst+2304(SB)/8, $0x00000000aa1181c2 +DATA ·IEEEConst+2312(SB)/8, $0x000000000361139c + +// x^112704 mod p(x), x^112640 mod p(x) +DATA ·IEEEConst+2320(SB)/8, $0x00000000ddd08002 +DATA ·IEEEConst+2328(SB)/8, $0x00000001a5a1a3a8 + +// x^111680 mod p(x), x^111616 mod p(x) +DATA ·IEEEConst+2336(SB)/8, $0x00000000e8dd0446 +DATA ·IEEEConst+2344(SB)/8, $0x000000006844e0b0 + +// x^110656 mod p(x), x^110592 mod p(x) +DATA ·IEEEConst+2352(SB)/8, $0x00000001bbd94a00 +DATA ·IEEEConst+2360(SB)/8, $0x00000000c3762f28 + +// x^109632 mod p(x), x^109568 mod p(x) +DATA ·IEEEConst+2368(SB)/8, $0x00000000ab6cd180 +DATA ·IEEEConst+2376(SB)/8, $0x00000001d26287a2 + +// x^108608 mod p(x), x^108544 mod p(x) +DATA ·IEEEConst+2384(SB)/8, $0x0000000031803ce2 +DATA ·IEEEConst+2392(SB)/8, $0x00000001f6f0bba8 + +// x^107584 mod p(x), x^107520 mod p(x) +DATA ·IEEEConst+2400(SB)/8, $0x0000000024f40b0c +DATA ·IEEEConst+2408(SB)/8, $0x000000002ffabd62 + +// x^106560 mod p(x), x^106496 mod p(x) +DATA ·IEEEConst+2416(SB)/8, $0x00000001ba1d9834 +DATA ·IEEEConst+2424(SB)/8, $0x00000000fb4516b8 + +// x^105536 mod p(x), x^105472 mod p(x) +DATA ·IEEEConst+2432(SB)/8, $0x0000000104de61aa +DATA ·IEEEConst+2440(SB)/8, $0x000000018cfa961c + +// x^104512 mod p(x), x^104448 mod p(x) +DATA ·IEEEConst+2448(SB)/8, $0x0000000113e40d46 +DATA ·IEEEConst+2456(SB)/8, $0x000000019e588d52 + +// x^103488 mod p(x), x^103424 mod p(x) +DATA ·IEEEConst+2464(SB)/8, $0x00000001415598a0 +DATA ·IEEEConst+2472(SB)/8, $0x00000001180f0bbc + +// x^102464 mod p(x), x^102400 mod p(x) +DATA ·IEEEConst+2480(SB)/8, $0x00000000bf6c8c90 +DATA ·IEEEConst+2488(SB)/8, $0x00000000e1d9177a + +// x^101440 mod p(x), x^101376 mod p(x) +DATA ·IEEEConst+2496(SB)/8, $0x00000001788b0504 +DATA ·IEEEConst+2504(SB)/8, $0x0000000105abc27c + +// x^100416 mod p(x), x^100352 mod p(x) +DATA ·IEEEConst+2512(SB)/8, $0x0000000038385d02 +DATA ·IEEEConst+2520(SB)/8, $0x00000000972e4a58 + +// x^99392 mod p(x), x^99328 mod p(x) +DATA ·IEEEConst+2528(SB)/8, $0x00000001b6c83844 +DATA ·IEEEConst+2536(SB)/8, $0x0000000183499a5e + +// x^98368 mod p(x), x^98304 mod p(x) +DATA ·IEEEConst+2544(SB)/8, $0x0000000051061a8a +DATA ·IEEEConst+2552(SB)/8, $0x00000001c96a8cca + +// x^97344 mod p(x), x^97280 mod p(x) +DATA ·IEEEConst+2560(SB)/8, $0x000000017351388a +DATA ·IEEEConst+2568(SB)/8, $0x00000001a1a5b60c + +// x^96320 mod p(x), x^96256 mod p(x) +DATA ·IEEEConst+2576(SB)/8, $0x0000000132928f92 +DATA ·IEEEConst+2584(SB)/8, $0x00000000e4b6ac9c + +// x^95296 mod p(x), x^95232 mod p(x) +DATA ·IEEEConst+2592(SB)/8, $0x00000000e6b4f48a +DATA ·IEEEConst+2600(SB)/8, $0x00000001807e7f5a + +// x^94272 mod p(x), x^94208 mod p(x) +DATA ·IEEEConst+2608(SB)/8, $0x0000000039d15e90 +DATA ·IEEEConst+2616(SB)/8, $0x000000017a7e3bc8 + +// x^93248 mod p(x), x^93184 mod p(x) +DATA ·IEEEConst+2624(SB)/8, $0x00000000312d6074 +DATA ·IEEEConst+2632(SB)/8, $0x00000000d73975da + +// x^92224 mod p(x), x^92160 mod p(x) +DATA ·IEEEConst+2640(SB)/8, $0x000000017bbb2cc4 +DATA ·IEEEConst+2648(SB)/8, $0x000000017375d038 + +// x^91200 mod p(x), x^91136 mod p(x) +DATA ·IEEEConst+2656(SB)/8, $0x000000016ded3e18 +DATA ·IEEEConst+2664(SB)/8, $0x00000000193680bc + +// x^90176 mod p(x), x^90112 mod p(x) +DATA ·IEEEConst+2672(SB)/8, $0x00000000f1638b16 +DATA ·IEEEConst+2680(SB)/8, $0x00000000999b06f6 + +// x^89152 mod p(x), x^89088 mod p(x) +DATA ·IEEEConst+2688(SB)/8, $0x00000001d38b9ecc +DATA ·IEEEConst+2696(SB)/8, $0x00000001f685d2b8 + +// x^88128 mod p(x), x^88064 mod p(x) +DATA ·IEEEConst+2704(SB)/8, $0x000000018b8d09dc +DATA ·IEEEConst+2712(SB)/8, $0x00000001f4ecbed2 + +// x^87104 mod p(x), x^87040 mod p(x) +DATA ·IEEEConst+2720(SB)/8, $0x00000000e7bc27d2 +DATA ·IEEEConst+2728(SB)/8, $0x00000000ba16f1a0 + +// x^86080 mod p(x), x^86016 mod p(x) +DATA ·IEEEConst+2736(SB)/8, $0x00000000275e1e96 +DATA ·IEEEConst+2744(SB)/8, $0x0000000115aceac4 + +// x^85056 mod p(x), x^84992 mod p(x) +DATA ·IEEEConst+2752(SB)/8, $0x00000000e2e3031e +DATA ·IEEEConst+2760(SB)/8, $0x00000001aeff6292 + +// x^84032 mod p(x), x^83968 mod p(x) +DATA ·IEEEConst+2768(SB)/8, $0x00000001041c84d8 +DATA ·IEEEConst+2776(SB)/8, $0x000000009640124c + +// x^83008 mod p(x), x^82944 mod p(x) +DATA ·IEEEConst+2784(SB)/8, $0x00000000706ce672 +DATA ·IEEEConst+2792(SB)/8, $0x0000000114f41f02 + +// x^81984 mod p(x), x^81920 mod p(x) +DATA ·IEEEConst+2800(SB)/8, $0x000000015d5070da +DATA ·IEEEConst+2808(SB)/8, $0x000000009c5f3586 + +// x^80960 mod p(x), x^80896 mod p(x) +DATA ·IEEEConst+2816(SB)/8, $0x0000000038f9493a +DATA ·IEEEConst+2824(SB)/8, $0x00000001878275fa + +// x^79936 mod p(x), x^79872 mod p(x) +DATA ·IEEEConst+2832(SB)/8, $0x00000000a3348a76 +DATA ·IEEEConst+2840(SB)/8, $0x00000000ddc42ce8 + +// x^78912 mod p(x), x^78848 mod p(x) +DATA ·IEEEConst+2848(SB)/8, $0x00000001ad0aab92 +DATA ·IEEEConst+2856(SB)/8, $0x0000000181d2c73a + +// x^77888 mod p(x), x^77824 mod p(x) +DATA ·IEEEConst+2864(SB)/8, $0x000000019e85f712 +DATA ·IEEEConst+2872(SB)/8, $0x0000000141c9320a + +// x^76864 mod p(x), x^76800 mod p(x) +DATA ·IEEEConst+2880(SB)/8, $0x000000005a871e76 +DATA ·IEEEConst+2888(SB)/8, $0x000000015235719a + +// x^75840 mod p(x), x^75776 mod p(x) +DATA ·IEEEConst+2896(SB)/8, $0x000000017249c662 +DATA ·IEEEConst+2904(SB)/8, $0x00000000be27d804 + +// x^74816 mod p(x), x^74752 mod p(x) +DATA ·IEEEConst+2912(SB)/8, $0x000000003a084712 +DATA ·IEEEConst+2920(SB)/8, $0x000000006242d45a + +// x^73792 mod p(x), x^73728 mod p(x) +DATA ·IEEEConst+2928(SB)/8, $0x00000000ed438478 +DATA ·IEEEConst+2936(SB)/8, $0x000000009a53638e + +// x^72768 mod p(x), x^72704 mod p(x) +DATA ·IEEEConst+2944(SB)/8, $0x00000000abac34cc +DATA ·IEEEConst+2952(SB)/8, $0x00000001001ecfb6 + +// x^71744 mod p(x), x^71680 mod p(x) +DATA ·IEEEConst+2960(SB)/8, $0x000000005f35ef3e +DATA ·IEEEConst+2968(SB)/8, $0x000000016d7c2d64 + +// x^70720 mod p(x), x^70656 mod p(x) +DATA ·IEEEConst+2976(SB)/8, $0x0000000047d6608c +DATA ·IEEEConst+2984(SB)/8, $0x00000001d0ce46c0 + +// x^69696 mod p(x), x^69632 mod p(x) +DATA ·IEEEConst+2992(SB)/8, $0x000000002d01470e +DATA ·IEEEConst+3000(SB)/8, $0x0000000124c907b4 + +// x^68672 mod p(x), x^68608 mod p(x) +DATA ·IEEEConst+3008(SB)/8, $0x0000000158bbc7b0 +DATA ·IEEEConst+3016(SB)/8, $0x0000000018a555ca + +// x^67648 mod p(x), x^67584 mod p(x) +DATA ·IEEEConst+3024(SB)/8, $0x00000000c0a23e8e +DATA ·IEEEConst+3032(SB)/8, $0x000000006b0980bc + +// x^66624 mod p(x), x^66560 mod p(x) +DATA ·IEEEConst+3040(SB)/8, $0x00000001ebd85c88 +DATA ·IEEEConst+3048(SB)/8, $0x000000008bbba964 + +// x^65600 mod p(x), x^65536 mod p(x) +DATA ·IEEEConst+3056(SB)/8, $0x000000019ee20bb2 +DATA ·IEEEConst+3064(SB)/8, $0x00000001070a5a1e + +// x^64576 mod p(x), x^64512 mod p(x) +DATA ·IEEEConst+3072(SB)/8, $0x00000001acabf2d6 +DATA ·IEEEConst+3080(SB)/8, $0x000000002204322a + +// x^63552 mod p(x), x^63488 mod p(x) +DATA ·IEEEConst+3088(SB)/8, $0x00000001b7963d56 +DATA ·IEEEConst+3096(SB)/8, $0x00000000a27524d0 + +// x^62528 mod p(x), x^62464 mod p(x) +DATA ·IEEEConst+3104(SB)/8, $0x000000017bffa1fe +DATA ·IEEEConst+3112(SB)/8, $0x0000000020b1e4ba + +// x^61504 mod p(x), x^61440 mod p(x) +DATA ·IEEEConst+3120(SB)/8, $0x000000001f15333e +DATA ·IEEEConst+3128(SB)/8, $0x0000000032cc27fc + +// x^60480 mod p(x), x^60416 mod p(x) +DATA ·IEEEConst+3136(SB)/8, $0x000000018593129e +DATA ·IEEEConst+3144(SB)/8, $0x0000000044dd22b8 + +// x^59456 mod p(x), x^59392 mod p(x) +DATA ·IEEEConst+3152(SB)/8, $0x000000019cb32602 +DATA ·IEEEConst+3160(SB)/8, $0x00000000dffc9e0a + +// x^58432 mod p(x), x^58368 mod p(x) +DATA ·IEEEConst+3168(SB)/8, $0x0000000142b05cc8 +DATA ·IEEEConst+3176(SB)/8, $0x00000001b7a0ed14 + +// x^57408 mod p(x), x^57344 mod p(x) +DATA ·IEEEConst+3184(SB)/8, $0x00000001be49e7a4 +DATA ·IEEEConst+3192(SB)/8, $0x00000000c7842488 + +// x^56384 mod p(x), x^56320 mod p(x) +DATA ·IEEEConst+3200(SB)/8, $0x0000000108f69d6c +DATA ·IEEEConst+3208(SB)/8, $0x00000001c02a4fee + +// x^55360 mod p(x), x^55296 mod p(x) +DATA ·IEEEConst+3216(SB)/8, $0x000000006c0971f0 +DATA ·IEEEConst+3224(SB)/8, $0x000000003c273778 + +// x^54336 mod p(x), x^54272 mod p(x) +DATA ·IEEEConst+3232(SB)/8, $0x000000005b16467a +DATA ·IEEEConst+3240(SB)/8, $0x00000001d63f8894 + +// x^53312 mod p(x), x^53248 mod p(x) +DATA ·IEEEConst+3248(SB)/8, $0x00000001551a628e +DATA ·IEEEConst+3256(SB)/8, $0x000000006be557d6 + +// x^52288 mod p(x), x^52224 mod p(x) +DATA ·IEEEConst+3264(SB)/8, $0x000000019e42ea92 +DATA ·IEEEConst+3272(SB)/8, $0x000000006a7806ea + +// x^51264 mod p(x), x^51200 mod p(x) +DATA ·IEEEConst+3280(SB)/8, $0x000000012fa83ff2 +DATA ·IEEEConst+3288(SB)/8, $0x000000016155aa0c + +// x^50240 mod p(x), x^50176 mod p(x) +DATA ·IEEEConst+3296(SB)/8, $0x000000011ca9cde0 +DATA ·IEEEConst+3304(SB)/8, $0x00000000908650ac + +// x^49216 mod p(x), x^49152 mod p(x) +DATA ·IEEEConst+3312(SB)/8, $0x00000000c8e5cd74 +DATA ·IEEEConst+3320(SB)/8, $0x00000000aa5a8084 + +// x^48192 mod p(x), x^48128 mod p(x) +DATA ·IEEEConst+3328(SB)/8, $0x0000000096c27f0c +DATA ·IEEEConst+3336(SB)/8, $0x0000000191bb500a + +// x^47168 mod p(x), x^47104 mod p(x) +DATA ·IEEEConst+3344(SB)/8, $0x000000002baed926 +DATA ·IEEEConst+3352(SB)/8, $0x0000000064e9bed0 + +// x^46144 mod p(x), x^46080 mod p(x) +DATA ·IEEEConst+3360(SB)/8, $0x000000017c8de8d2 +DATA ·IEEEConst+3368(SB)/8, $0x000000009444f302 + +// x^45120 mod p(x), x^45056 mod p(x) +DATA ·IEEEConst+3376(SB)/8, $0x00000000d43d6068 +DATA ·IEEEConst+3384(SB)/8, $0x000000019db07d3c + +// x^44096 mod p(x), x^44032 mod p(x) +DATA ·IEEEConst+3392(SB)/8, $0x00000000cb2c4b26 +DATA ·IEEEConst+3400(SB)/8, $0x00000001359e3e6e + +// x^43072 mod p(x), x^43008 mod p(x) +DATA ·IEEEConst+3408(SB)/8, $0x0000000145b8da26 +DATA ·IEEEConst+3416(SB)/8, $0x00000001e4f10dd2 + +// x^42048 mod p(x), x^41984 mod p(x) +DATA ·IEEEConst+3424(SB)/8, $0x000000018fff4b08 +DATA ·IEEEConst+3432(SB)/8, $0x0000000124f5735e + +// x^41024 mod p(x), x^40960 mod p(x) +DATA ·IEEEConst+3440(SB)/8, $0x0000000150b58ed0 +DATA ·IEEEConst+3448(SB)/8, $0x0000000124760a4c + +// x^40000 mod p(x), x^39936 mod p(x) +DATA ·IEEEConst+3456(SB)/8, $0x00000001549f39bc +DATA ·IEEEConst+3464(SB)/8, $0x000000000f1fc186 + +// x^38976 mod p(x), x^38912 mod p(x) +DATA ·IEEEConst+3472(SB)/8, $0x00000000ef4d2f42 +DATA ·IEEEConst+3480(SB)/8, $0x00000000150e4cc4 + +// x^37952 mod p(x), x^37888 mod p(x) +DATA ·IEEEConst+3488(SB)/8, $0x00000001b1468572 +DATA ·IEEEConst+3496(SB)/8, $0x000000002a6204e8 + +// x^36928 mod p(x), x^36864 mod p(x) +DATA ·IEEEConst+3504(SB)/8, $0x000000013d7403b2 +DATA ·IEEEConst+3512(SB)/8, $0x00000000beb1d432 + +// x^35904 mod p(x), x^35840 mod p(x) +DATA ·IEEEConst+3520(SB)/8, $0x00000001a4681842 +DATA ·IEEEConst+3528(SB)/8, $0x0000000135f3f1f0 + +// x^34880 mod p(x), x^34816 mod p(x) +DATA ·IEEEConst+3536(SB)/8, $0x0000000167714492 +DATA ·IEEEConst+3544(SB)/8, $0x0000000074fe2232 + +// x^33856 mod p(x), x^33792 mod p(x) +DATA ·IEEEConst+3552(SB)/8, $0x00000001e599099a +DATA ·IEEEConst+3560(SB)/8, $0x000000001ac6e2ba + +// x^32832 mod p(x), x^32768 mod p(x) +DATA ·IEEEConst+3568(SB)/8, $0x00000000fe128194 +DATA ·IEEEConst+3576(SB)/8, $0x0000000013fca91e + +// x^31808 mod p(x), x^31744 mod p(x) +DATA ·IEEEConst+3584(SB)/8, $0x0000000077e8b990 +DATA ·IEEEConst+3592(SB)/8, $0x0000000183f4931e + +// x^30784 mod p(x), x^30720 mod p(x) +DATA ·IEEEConst+3600(SB)/8, $0x00000001a267f63a +DATA ·IEEEConst+3608(SB)/8, $0x00000000b6d9b4e4 + +// x^29760 mod p(x), x^29696 mod p(x) +DATA ·IEEEConst+3616(SB)/8, $0x00000001945c245a +DATA ·IEEEConst+3624(SB)/8, $0x00000000b5188656 + +// x^28736 mod p(x), x^28672 mod p(x) +DATA ·IEEEConst+3632(SB)/8, $0x0000000149002e76 +DATA ·IEEEConst+3640(SB)/8, $0x0000000027a81a84 + +// x^27712 mod p(x), x^27648 mod p(x) +DATA ·IEEEConst+3648(SB)/8, $0x00000001bb8310a4 +DATA ·IEEEConst+3656(SB)/8, $0x0000000125699258 + +// x^26688 mod p(x), x^26624 mod p(x) +DATA ·IEEEConst+3664(SB)/8, $0x000000019ec60bcc +DATA ·IEEEConst+3672(SB)/8, $0x00000001b23de796 + +// x^25664 mod p(x), x^25600 mod p(x) +DATA ·IEEEConst+3680(SB)/8, $0x000000012d8590ae +DATA ·IEEEConst+3688(SB)/8, $0x00000000fe4365dc + +// x^24640 mod p(x), x^24576 mod p(x) +DATA ·IEEEConst+3696(SB)/8, $0x0000000065b00684 +DATA ·IEEEConst+3704(SB)/8, $0x00000000c68f497a + +// x^23616 mod p(x), x^23552 mod p(x) +DATA ·IEEEConst+3712(SB)/8, $0x000000015e5aeadc +DATA ·IEEEConst+3720(SB)/8, $0x00000000fbf521ee + +// x^22592 mod p(x), x^22528 mod p(x) +DATA ·IEEEConst+3728(SB)/8, $0x00000000b77ff2b0 +DATA ·IEEEConst+3736(SB)/8, $0x000000015eac3378 + +// x^21568 mod p(x), x^21504 mod p(x) +DATA ·IEEEConst+3744(SB)/8, $0x0000000188da2ff6 +DATA ·IEEEConst+3752(SB)/8, $0x0000000134914b90 + +// x^20544 mod p(x), x^20480 mod p(x) +DATA ·IEEEConst+3760(SB)/8, $0x0000000063da929a +DATA ·IEEEConst+3768(SB)/8, $0x0000000016335cfe + +// x^19520 mod p(x), x^19456 mod p(x) +DATA ·IEEEConst+3776(SB)/8, $0x00000001389caa80 +DATA ·IEEEConst+3784(SB)/8, $0x000000010372d10c + +// x^18496 mod p(x), x^18432 mod p(x) +DATA ·IEEEConst+3792(SB)/8, $0x000000013db599d2 +DATA ·IEEEConst+3800(SB)/8, $0x000000015097b908 + +// x^17472 mod p(x), x^17408 mod p(x) +DATA ·IEEEConst+3808(SB)/8, $0x0000000122505a86 +DATA ·IEEEConst+3816(SB)/8, $0x00000001227a7572 + +// x^16448 mod p(x), x^16384 mod p(x) +DATA ·IEEEConst+3824(SB)/8, $0x000000016bd72746 +DATA ·IEEEConst+3832(SB)/8, $0x000000009a8f75c0 + +// x^15424 mod p(x), x^15360 mod p(x) +DATA ·IEEEConst+3840(SB)/8, $0x00000001c3faf1d4 +DATA ·IEEEConst+3848(SB)/8, $0x00000000682c77a2 + +// x^14400 mod p(x), x^14336 mod p(x) +DATA ·IEEEConst+3856(SB)/8, $0x00000001111c826c +DATA ·IEEEConst+3864(SB)/8, $0x00000000231f091c + +// x^13376 mod p(x), x^13312 mod p(x) +DATA ·IEEEConst+3872(SB)/8, $0x00000000153e9fb2 +DATA ·IEEEConst+3880(SB)/8, $0x000000007d4439f2 + +// x^12352 mod p(x), x^12288 mod p(x) +DATA ·IEEEConst+3888(SB)/8, $0x000000002b1f7b60 +DATA ·IEEEConst+3896(SB)/8, $0x000000017e221efc + +// x^11328 mod p(x), x^11264 mod p(x) +DATA ·IEEEConst+3904(SB)/8, $0x00000000b1dba570 +DATA ·IEEEConst+3912(SB)/8, $0x0000000167457c38 + +// x^10304 mod p(x), x^10240 mod p(x) +DATA ·IEEEConst+3920(SB)/8, $0x00000001f6397b76 +DATA ·IEEEConst+3928(SB)/8, $0x00000000bdf081c4 + +// x^9280 mod p(x), x^9216 mod p(x) +DATA ·IEEEConst+3936(SB)/8, $0x0000000156335214 +DATA ·IEEEConst+3944(SB)/8, $0x000000016286d6b0 + +// x^8256 mod p(x), x^8192 mod p(x) +DATA ·IEEEConst+3952(SB)/8, $0x00000001d70e3986 +DATA ·IEEEConst+3960(SB)/8, $0x00000000c84f001c + +// x^7232 mod p(x), x^7168 mod p(x) +DATA ·IEEEConst+3968(SB)/8, $0x000000003701a774 +DATA ·IEEEConst+3976(SB)/8, $0x0000000064efe7c0 + +// x^6208 mod p(x), x^6144 mod p(x) +DATA ·IEEEConst+3984(SB)/8, $0x00000000ac81ef72 +DATA ·IEEEConst+3992(SB)/8, $0x000000000ac2d904 + +// x^5184 mod p(x), x^5120 mod p(x) +DATA ·IEEEConst+4000(SB)/8, $0x0000000133212464 +DATA ·IEEEConst+4008(SB)/8, $0x00000000fd226d14 + +// x^4160 mod p(x), x^4096 mod p(x) +DATA ·IEEEConst+4016(SB)/8, $0x00000000e4e45610 +DATA ·IEEEConst+4024(SB)/8, $0x000000011cfd42e0 + +// x^3136 mod p(x), x^3072 mod p(x) +DATA ·IEEEConst+4032(SB)/8, $0x000000000c1bd370 +DATA ·IEEEConst+4040(SB)/8, $0x000000016e5a5678 + +// x^2112 mod p(x), x^2048 mod p(x) +DATA ·IEEEConst+4048(SB)/8, $0x00000001a7b9e7a6 +DATA ·IEEEConst+4056(SB)/8, $0x00000001d888fe22 + +// x^1088 mod p(x), x^1024 mod p(x) +DATA ·IEEEConst+4064(SB)/8, $0x000000007d657a10 +DATA ·IEEEConst+4072(SB)/8, $0x00000001af77fcd4 + +// x^2048 mod p(x), x^2016 mod p(x), x^1984 mod p(x), x^1952 mod p(x) +DATA ·IEEEConst+4080(SB)/8, $0x99168a18ec447f11 +DATA ·IEEEConst+4088(SB)/8, $0xed837b2613e8221e + +// x^1920 mod p(x), x^1888 mod p(x), x^1856 mod p(x), x^1824 mod p(x) +DATA ·IEEEConst+4096(SB)/8, $0xe23e954e8fd2cd3c +DATA ·IEEEConst+4104(SB)/8, $0xc8acdd8147b9ce5a + +// x^1792 mod p(x), x^1760 mod p(x), x^1728 mod p(x), x^1696 mod p(x) +DATA ·IEEEConst+4112(SB)/8, $0x92f8befe6b1d2b53 +DATA ·IEEEConst+4120(SB)/8, $0xd9ad6d87d4277e25 + +// x^1664 mod p(x), x^1632 mod p(x), x^1600 mod p(x), x^1568 mod p(x) +DATA ·IEEEConst+4128(SB)/8, $0xf38a3556291ea462 +DATA ·IEEEConst+4136(SB)/8, $0xc10ec5e033fbca3b + +// x^1536 mod p(x), x^1504 mod p(x), x^1472 mod p(x), x^1440 mod p(x) +DATA ·IEEEConst+4144(SB)/8, $0x974ac56262b6ca4b +DATA ·IEEEConst+4152(SB)/8, $0xc0b55b0e82e02e2f + +// x^1408 mod p(x), x^1376 mod p(x), x^1344 mod p(x), x^1312 mod p(x) +DATA ·IEEEConst+4160(SB)/8, $0x855712b3784d2a56 +DATA ·IEEEConst+4168(SB)/8, $0x71aa1df0e172334d + +// x^1280 mod p(x), x^1248 mod p(x), x^1216 mod p(x), x^1184 mod p(x) +DATA ·IEEEConst+4176(SB)/8, $0xa5abe9f80eaee722 +DATA ·IEEEConst+4184(SB)/8, $0xfee3053e3969324d + +// x^1152 mod p(x), x^1120 mod p(x), x^1088 mod p(x), x^1056 mod p(x) +DATA ·IEEEConst+4192(SB)/8, $0x1fa0943ddb54814c +DATA ·IEEEConst+4200(SB)/8, $0xf44779b93eb2bd08 + +// x^1024 mod p(x), x^992 mod p(x), x^960 mod p(x), x^928 mod p(x) +DATA ·IEEEConst+4208(SB)/8, $0xa53ff440d7bbfe6a +DATA ·IEEEConst+4216(SB)/8, $0xf5449b3f00cc3374 + +// x^896 mod p(x), x^864 mod p(x), x^832 mod p(x), x^800 mod p(x) +DATA ·IEEEConst+4224(SB)/8, $0xebe7e3566325605c +DATA ·IEEEConst+4232(SB)/8, $0x6f8346e1d777606e + +// x^768 mod p(x), x^736 mod p(x), x^704 mod p(x), x^672 mod p(x) +DATA ·IEEEConst+4240(SB)/8, $0xc65a272ce5b592b8 +DATA ·IEEEConst+4248(SB)/8, $0xe3ab4f2ac0b95347 + +// x^640 mod p(x), x^608 mod p(x), x^576 mod p(x), x^544 mod p(x) +DATA ·IEEEConst+4256(SB)/8, $0x5705a9ca4721589f +DATA ·IEEEConst+4264(SB)/8, $0xaa2215ea329ecc11 + +// x^512 mod p(x), x^480 mod p(x), x^448 mod p(x), x^416 mod p(x) +DATA ·IEEEConst+4272(SB)/8, $0xe3720acb88d14467 +DATA ·IEEEConst+4280(SB)/8, $0x1ed8f66ed95efd26 + +// x^384 mod p(x), x^352 mod p(x), x^320 mod p(x), x^288 mod p(x) +DATA ·IEEEConst+4288(SB)/8, $0xba1aca0315141c31 +DATA ·IEEEConst+4296(SB)/8, $0x78ed02d5a700e96a + +// x^256 mod p(x), x^224 mod p(x), x^192 mod p(x), x^160 mod p(x) +DATA ·IEEEConst+4304(SB)/8, $0xad2a31b3ed627dae +DATA ·IEEEConst+4312(SB)/8, $0xba8ccbe832b39da3 + +// x^128 mod p(x), x^96 mod p(x), x^64 mod p(x), x^32 mod p(x) +DATA ·IEEEConst+4320(SB)/8, $0x6655004fa06a2517 +DATA ·IEEEConst+4328(SB)/8, $0xedb88320b1e6b092 + +GLOBL ·IEEEConst(SB), RODATA, $4336 + +// Barrett constant m - (4^32)/n +DATA ·IEEEBarConst(SB)/8, $0x00000001f7011641 +DATA ·IEEEBarConst+8(SB)/8, $0x0000000000000000 +DATA ·IEEEBarConst+16(SB)/8, $0x00000001db710641 +DATA ·IEEEBarConst+24(SB)/8, $0x0000000000000000 +GLOBL ·IEEEBarConst(SB), RODATA, $32 + +// Reduce 262144 kbits to 1024 bits +// x^261184 mod p(x), x^261120 mod p(x) +DATA ·CastConst+0(SB)/8, $0x000000009c37c408 +DATA ·CastConst+8(SB)/8, $0x00000000b6ca9e20 + +// x^260160 mod p(x), x^260096 mod p(x) +DATA ·CastConst+16(SB)/8, $0x00000001b51df26c +DATA ·CastConst+24(SB)/8, $0x00000000350249a8 + +// x^259136 mod p(x), x^259072 mod p(x) +DATA ·CastConst+32(SB)/8, $0x000000000724b9d0 +DATA ·CastConst+40(SB)/8, $0x00000001862dac54 + +// x^258112 mod p(x), x^258048 mod p(x) +DATA ·CastConst+48(SB)/8, $0x00000001c00532fe +DATA ·CastConst+56(SB)/8, $0x00000001d87fb48c + +// x^257088 mod p(x), x^257024 mod p(x) +DATA ·CastConst+64(SB)/8, $0x00000000f05a9362 +DATA ·CastConst+72(SB)/8, $0x00000001f39b699e + +// x^256064 mod p(x), x^256000 mod p(x) +DATA ·CastConst+80(SB)/8, $0x00000001e1007970 +DATA ·CastConst+88(SB)/8, $0x0000000101da11b4 + +// x^255040 mod p(x), x^254976 mod p(x) +DATA ·CastConst+96(SB)/8, $0x00000000a57366ee +DATA ·CastConst+104(SB)/8, $0x00000001cab571e0 + +// x^254016 mod p(x), x^253952 mod p(x) +DATA ·CastConst+112(SB)/8, $0x0000000192011284 +DATA ·CastConst+120(SB)/8, $0x00000000c7020cfe + +// x^252992 mod p(x), x^252928 mod p(x) +DATA ·CastConst+128(SB)/8, $0x0000000162716d9a +DATA ·CastConst+136(SB)/8, $0x00000000cdaed1ae + +// x^251968 mod p(x), x^251904 mod p(x) +DATA ·CastConst+144(SB)/8, $0x00000000cd97ecde +DATA ·CastConst+152(SB)/8, $0x00000001e804effc + +// x^250944 mod p(x), x^250880 mod p(x) +DATA ·CastConst+160(SB)/8, $0x0000000058812bc0 +DATA ·CastConst+168(SB)/8, $0x0000000077c3ea3a + +// x^249920 mod p(x), x^249856 mod p(x) +DATA ·CastConst+176(SB)/8, $0x0000000088b8c12e +DATA ·CastConst+184(SB)/8, $0x0000000068df31b4 + +// x^248896 mod p(x), x^248832 mod p(x) +DATA ·CastConst+192(SB)/8, $0x00000001230b234c +DATA ·CastConst+200(SB)/8, $0x00000000b059b6c2 + +// x^247872 mod p(x), x^247808 mod p(x) +DATA ·CastConst+208(SB)/8, $0x00000001120b416e +DATA ·CastConst+216(SB)/8, $0x0000000145fb8ed8 + +// x^246848 mod p(x), x^246784 mod p(x) +DATA ·CastConst+224(SB)/8, $0x00000001974aecb0 +DATA ·CastConst+232(SB)/8, $0x00000000cbc09168 + +// x^245824 mod p(x), x^245760 mod p(x) +DATA ·CastConst+240(SB)/8, $0x000000008ee3f226 +DATA ·CastConst+248(SB)/8, $0x000000005ceeedc2 + +// x^244800 mod p(x), x^244736 mod p(x) +DATA ·CastConst+256(SB)/8, $0x00000001089aba9a +DATA ·CastConst+264(SB)/8, $0x0000000047d74e86 + +// x^243776 mod p(x), x^243712 mod p(x) +DATA ·CastConst+272(SB)/8, $0x0000000065113872 +DATA ·CastConst+280(SB)/8, $0x00000001407e9e22 + +// x^242752 mod p(x), x^242688 mod p(x) +DATA ·CastConst+288(SB)/8, $0x000000005c07ec10 +DATA ·CastConst+296(SB)/8, $0x00000001da967bda + +// x^241728 mod p(x), x^241664 mod p(x) +DATA ·CastConst+304(SB)/8, $0x0000000187590924 +DATA ·CastConst+312(SB)/8, $0x000000006c898368 + +// x^240704 mod p(x), x^240640 mod p(x) +DATA ·CastConst+320(SB)/8, $0x00000000e35da7c6 +DATA ·CastConst+328(SB)/8, $0x00000000f2d14c98 + +// x^239680 mod p(x), x^239616 mod p(x) +DATA ·CastConst+336(SB)/8, $0x000000000415855a +DATA ·CastConst+344(SB)/8, $0x00000001993c6ad4 + +// x^238656 mod p(x), x^238592 mod p(x) +DATA ·CastConst+352(SB)/8, $0x0000000073617758 +DATA ·CastConst+360(SB)/8, $0x000000014683d1ac + +// x^237632 mod p(x), x^237568 mod p(x) +DATA ·CastConst+368(SB)/8, $0x0000000176021d28 +DATA ·CastConst+376(SB)/8, $0x00000001a7c93e6c + +// x^236608 mod p(x), x^236544 mod p(x) +DATA ·CastConst+384(SB)/8, $0x00000001c358fd0a +DATA ·CastConst+392(SB)/8, $0x000000010211e90a + +// x^235584 mod p(x), x^235520 mod p(x) +DATA ·CastConst+400(SB)/8, $0x00000001ff7a2c18 +DATA ·CastConst+408(SB)/8, $0x000000001119403e + +// x^234560 mod p(x), x^234496 mod p(x) +DATA ·CastConst+416(SB)/8, $0x00000000f2d9f7e4 +DATA ·CastConst+424(SB)/8, $0x000000001c3261aa + +// x^233536 mod p(x), x^233472 mod p(x) +DATA ·CastConst+432(SB)/8, $0x000000016cf1f9c8 +DATA ·CastConst+440(SB)/8, $0x000000014e37a634 + +// x^232512 mod p(x), x^232448 mod p(x) +DATA ·CastConst+448(SB)/8, $0x000000010af9279a +DATA ·CastConst+456(SB)/8, $0x0000000073786c0c + +// x^231488 mod p(x), x^231424 mod p(x) +DATA ·CastConst+464(SB)/8, $0x0000000004f101e8 +DATA ·CastConst+472(SB)/8, $0x000000011dc037f8 + +// x^230464 mod p(x), x^230400 mod p(x) +DATA ·CastConst+480(SB)/8, $0x0000000070bcf184 +DATA ·CastConst+488(SB)/8, $0x0000000031433dfc + +// x^229440 mod p(x), x^229376 mod p(x) +DATA ·CastConst+496(SB)/8, $0x000000000a8de642 +DATA ·CastConst+504(SB)/8, $0x000000009cde8348 + +// x^228416 mod p(x), x^228352 mod p(x) +DATA ·CastConst+512(SB)/8, $0x0000000062ea130c +DATA ·CastConst+520(SB)/8, $0x0000000038d3c2a6 + +// x^227392 mod p(x), x^227328 mod p(x) +DATA ·CastConst+528(SB)/8, $0x00000001eb31cbb2 +DATA ·CastConst+536(SB)/8, $0x000000011b25f260 + +// x^226368 mod p(x), x^226304 mod p(x) +DATA ·CastConst+544(SB)/8, $0x0000000170783448 +DATA ·CastConst+552(SB)/8, $0x000000001629e6f0 + +// x^225344 mod p(x), x^225280 mod p(x) +DATA ·CastConst+560(SB)/8, $0x00000001a684b4c6 +DATA ·CastConst+568(SB)/8, $0x0000000160838b4c + +// x^224320 mod p(x), x^224256 mod p(x) +DATA ·CastConst+576(SB)/8, $0x00000000253ca5b4 +DATA ·CastConst+584(SB)/8, $0x000000007a44011c + +// x^223296 mod p(x), x^223232 mod p(x) +DATA ·CastConst+592(SB)/8, $0x0000000057b4b1e2 +DATA ·CastConst+600(SB)/8, $0x00000000226f417a + +// x^222272 mod p(x), x^222208 mod p(x) +DATA ·CastConst+608(SB)/8, $0x00000000b6bd084c +DATA ·CastConst+616(SB)/8, $0x0000000045eb2eb4 + +// x^221248 mod p(x), x^221184 mod p(x) +DATA ·CastConst+624(SB)/8, $0x0000000123c2d592 +DATA ·CastConst+632(SB)/8, $0x000000014459d70c + +// x^220224 mod p(x), x^220160 mod p(x) +DATA ·CastConst+640(SB)/8, $0x00000000159dafce +DATA ·CastConst+648(SB)/8, $0x00000001d406ed82 + +// x^219200 mod p(x), x^219136 mod p(x) +DATA ·CastConst+656(SB)/8, $0x0000000127e1a64e +DATA ·CastConst+664(SB)/8, $0x0000000160c8e1a8 + +// x^218176 mod p(x), x^218112 mod p(x) +DATA ·CastConst+672(SB)/8, $0x0000000056860754 +DATA ·CastConst+680(SB)/8, $0x0000000027ba8098 + +// x^217152 mod p(x), x^217088 mod p(x) +DATA ·CastConst+688(SB)/8, $0x00000001e661aae8 +DATA ·CastConst+696(SB)/8, $0x000000006d92d018 + +// x^216128 mod p(x), x^216064 mod p(x) +DATA ·CastConst+704(SB)/8, $0x00000000f82c6166 +DATA ·CastConst+712(SB)/8, $0x000000012ed7e3f2 + +// x^215104 mod p(x), x^215040 mod p(x) +DATA ·CastConst+720(SB)/8, $0x00000000c4f9c7ae +DATA ·CastConst+728(SB)/8, $0x000000002dc87788 + +// x^214080 mod p(x), x^214016 mod p(x) +DATA ·CastConst+736(SB)/8, $0x0000000074203d20 +DATA ·CastConst+744(SB)/8, $0x0000000018240bb8 + +// x^213056 mod p(x), x^212992 mod p(x) +DATA ·CastConst+752(SB)/8, $0x0000000198173052 +DATA ·CastConst+760(SB)/8, $0x000000001ad38158 + +// x^212032 mod p(x), x^211968 mod p(x) +DATA ·CastConst+768(SB)/8, $0x00000001ce8aba54 +DATA ·CastConst+776(SB)/8, $0x00000001396b78f2 + +// x^211008 mod p(x), x^210944 mod p(x) +DATA ·CastConst+784(SB)/8, $0x00000001850d5d94 +DATA ·CastConst+792(SB)/8, $0x000000011a681334 + +// x^209984 mod p(x), x^209920 mod p(x) +DATA ·CastConst+800(SB)/8, $0x00000001d609239c +DATA ·CastConst+808(SB)/8, $0x000000012104732e + +// x^208960 mod p(x), x^208896 mod p(x) +DATA ·CastConst+816(SB)/8, $0x000000001595f048 +DATA ·CastConst+824(SB)/8, $0x00000000a140d90c + +// x^207936 mod p(x), x^207872 mod p(x) +DATA ·CastConst+832(SB)/8, $0x0000000042ccee08 +DATA ·CastConst+840(SB)/8, $0x00000001b7215eda + +// x^206912 mod p(x), x^206848 mod p(x) +DATA ·CastConst+848(SB)/8, $0x000000010a389d74 +DATA ·CastConst+856(SB)/8, $0x00000001aaf1df3c + +// x^205888 mod p(x), x^205824 mod p(x) +DATA ·CastConst+864(SB)/8, $0x000000012a840da6 +DATA ·CastConst+872(SB)/8, $0x0000000029d15b8a + +// x^204864 mod p(x), x^204800 mod p(x) +DATA ·CastConst+880(SB)/8, $0x000000001d181c0c +DATA ·CastConst+888(SB)/8, $0x00000000f1a96922 + +// x^203840 mod p(x), x^203776 mod p(x) +DATA ·CastConst+896(SB)/8, $0x0000000068b7d1f6 +DATA ·CastConst+904(SB)/8, $0x00000001ac80d03c + +// x^202816 mod p(x), x^202752 mod p(x) +DATA ·CastConst+912(SB)/8, $0x000000005b0f14fc +DATA ·CastConst+920(SB)/8, $0x000000000f11d56a + +// x^201792 mod p(x), x^201728 mod p(x) +DATA ·CastConst+928(SB)/8, $0x0000000179e9e730 +DATA ·CastConst+936(SB)/8, $0x00000001f1c022a2 + +// x^200768 mod p(x), x^200704 mod p(x) +DATA ·CastConst+944(SB)/8, $0x00000001ce1368d6 +DATA ·CastConst+952(SB)/8, $0x0000000173d00ae2 + +// x^199744 mod p(x), x^199680 mod p(x) +DATA ·CastConst+960(SB)/8, $0x0000000112c3a84c +DATA ·CastConst+968(SB)/8, $0x00000001d4ffe4ac + +// x^198720 mod p(x), x^198656 mod p(x) +DATA ·CastConst+976(SB)/8, $0x00000000de940fee +DATA ·CastConst+984(SB)/8, $0x000000016edc5ae4 + +// x^197696 mod p(x), x^197632 mod p(x) +DATA ·CastConst+992(SB)/8, $0x00000000fe896b7e +DATA ·CastConst+1000(SB)/8, $0x00000001f1a02140 + +// x^196672 mod p(x), x^196608 mod p(x) +DATA ·CastConst+1008(SB)/8, $0x00000001f797431c +DATA ·CastConst+1016(SB)/8, $0x00000000ca0b28a0 + +// x^195648 mod p(x), x^195584 mod p(x) +DATA ·CastConst+1024(SB)/8, $0x0000000053e989ba +DATA ·CastConst+1032(SB)/8, $0x00000001928e30a2 + +// x^194624 mod p(x), x^194560 mod p(x) +DATA ·CastConst+1040(SB)/8, $0x000000003920cd16 +DATA ·CastConst+1048(SB)/8, $0x0000000097b1b002 + +// x^193600 mod p(x), x^193536 mod p(x) +DATA ·CastConst+1056(SB)/8, $0x00000001e6f579b8 +DATA ·CastConst+1064(SB)/8, $0x00000000b15bf906 + +// x^192576 mod p(x), x^192512 mod p(x) +DATA ·CastConst+1072(SB)/8, $0x000000007493cb0a +DATA ·CastConst+1080(SB)/8, $0x00000000411c5d52 + +// x^191552 mod p(x), x^191488 mod p(x) +DATA ·CastConst+1088(SB)/8, $0x00000001bdd376d8 +DATA ·CastConst+1096(SB)/8, $0x00000001c36f3300 + +// x^190528 mod p(x), x^190464 mod p(x) +DATA ·CastConst+1104(SB)/8, $0x000000016badfee6 +DATA ·CastConst+1112(SB)/8, $0x00000001119227e0 + +// x^189504 mod p(x), x^189440 mod p(x) +DATA ·CastConst+1120(SB)/8, $0x0000000071de5c58 +DATA ·CastConst+1128(SB)/8, $0x00000000114d4702 + +// x^188480 mod p(x), x^188416 mod p(x) +DATA ·CastConst+1136(SB)/8, $0x00000000453f317c +DATA ·CastConst+1144(SB)/8, $0x00000000458b5b98 + +// x^187456 mod p(x), x^187392 mod p(x) +DATA ·CastConst+1152(SB)/8, $0x0000000121675cce +DATA ·CastConst+1160(SB)/8, $0x000000012e31fb8e + +// x^186432 mod p(x), x^186368 mod p(x) +DATA ·CastConst+1168(SB)/8, $0x00000001f409ee92 +DATA ·CastConst+1176(SB)/8, $0x000000005cf619d8 + +// x^185408 mod p(x), x^185344 mod p(x) +DATA ·CastConst+1184(SB)/8, $0x00000000f36b9c88 +DATA ·CastConst+1192(SB)/8, $0x0000000063f4d8b2 + +// x^184384 mod p(x), x^184320 mod p(x) +DATA ·CastConst+1200(SB)/8, $0x0000000036b398f4 +DATA ·CastConst+1208(SB)/8, $0x000000004138dc8a + +// x^183360 mod p(x), x^183296 mod p(x) +DATA ·CastConst+1216(SB)/8, $0x00000001748f9adc +DATA ·CastConst+1224(SB)/8, $0x00000001d29ee8e0 + +// x^182336 mod p(x), x^182272 mod p(x) +DATA ·CastConst+1232(SB)/8, $0x00000001be94ec00 +DATA ·CastConst+1240(SB)/8, $0x000000006a08ace8 + +// x^181312 mod p(x), x^181248 mod p(x) +DATA ·CastConst+1248(SB)/8, $0x00000000b74370d6 +DATA ·CastConst+1256(SB)/8, $0x0000000127d42010 + +// x^180288 mod p(x), x^180224 mod p(x) +DATA ·CastConst+1264(SB)/8, $0x00000001174d0b98 +DATA ·CastConst+1272(SB)/8, $0x0000000019d76b62 + +// x^179264 mod p(x), x^179200 mod p(x) +DATA ·CastConst+1280(SB)/8, $0x00000000befc06a4 +DATA ·CastConst+1288(SB)/8, $0x00000001b1471f6e + +// x^178240 mod p(x), x^178176 mod p(x) +DATA ·CastConst+1296(SB)/8, $0x00000001ae125288 +DATA ·CastConst+1304(SB)/8, $0x00000001f64c19cc + +// x^177216 mod p(x), x^177152 mod p(x) +DATA ·CastConst+1312(SB)/8, $0x0000000095c19b34 +DATA ·CastConst+1320(SB)/8, $0x00000000003c0ea0 + +// x^176192 mod p(x), x^176128 mod p(x) +DATA ·CastConst+1328(SB)/8, $0x00000001a78496f2 +DATA ·CastConst+1336(SB)/8, $0x000000014d73abf6 + +// x^175168 mod p(x), x^175104 mod p(x) +DATA ·CastConst+1344(SB)/8, $0x00000001ac5390a0 +DATA ·CastConst+1352(SB)/8, $0x00000001620eb844 + +// x^174144 mod p(x), x^174080 mod p(x) +DATA ·CastConst+1360(SB)/8, $0x000000002a80ed6e +DATA ·CastConst+1368(SB)/8, $0x0000000147655048 + +// x^173120 mod p(x), x^173056 mod p(x) +DATA ·CastConst+1376(SB)/8, $0x00000001fa9b0128 +DATA ·CastConst+1384(SB)/8, $0x0000000067b5077e + +// x^172096 mod p(x), x^172032 mod p(x) +DATA ·CastConst+1392(SB)/8, $0x00000001ea94929e +DATA ·CastConst+1400(SB)/8, $0x0000000010ffe206 + +// x^171072 mod p(x), x^171008 mod p(x) +DATA ·CastConst+1408(SB)/8, $0x0000000125f4305c +DATA ·CastConst+1416(SB)/8, $0x000000000fee8f1e + +// x^170048 mod p(x), x^169984 mod p(x) +DATA ·CastConst+1424(SB)/8, $0x00000001471e2002 +DATA ·CastConst+1432(SB)/8, $0x00000001da26fbae + +// x^169024 mod p(x), x^168960 mod p(x) +DATA ·CastConst+1440(SB)/8, $0x0000000132d2253a +DATA ·CastConst+1448(SB)/8, $0x00000001b3a8bd88 + +// x^168000 mod p(x), x^167936 mod p(x) +DATA ·CastConst+1456(SB)/8, $0x00000000f26b3592 +DATA ·CastConst+1464(SB)/8, $0x00000000e8f3898e + +// x^166976 mod p(x), x^166912 mod p(x) +DATA ·CastConst+1472(SB)/8, $0x00000000bc8b67b0 +DATA ·CastConst+1480(SB)/8, $0x00000000b0d0d28c + +// x^165952 mod p(x), x^165888 mod p(x) +DATA ·CastConst+1488(SB)/8, $0x000000013a826ef2 +DATA ·CastConst+1496(SB)/8, $0x0000000030f2a798 + +// x^164928 mod p(x), x^164864 mod p(x) +DATA ·CastConst+1504(SB)/8, $0x0000000081482c84 +DATA ·CastConst+1512(SB)/8, $0x000000000fba1002 + +// x^163904 mod p(x), x^163840 mod p(x) +DATA ·CastConst+1520(SB)/8, $0x00000000e77307c2 +DATA ·CastConst+1528(SB)/8, $0x00000000bdb9bd72 + +// x^162880 mod p(x), x^162816 mod p(x) +DATA ·CastConst+1536(SB)/8, $0x00000000d4a07ec8 +DATA ·CastConst+1544(SB)/8, $0x0000000075d3bf5a + +// x^161856 mod p(x), x^161792 mod p(x) +DATA ·CastConst+1552(SB)/8, $0x0000000017102100 +DATA ·CastConst+1560(SB)/8, $0x00000000ef1f98a0 + +// x^160832 mod p(x), x^160768 mod p(x) +DATA ·CastConst+1568(SB)/8, $0x00000000db406486 +DATA ·CastConst+1576(SB)/8, $0x00000000689c7602 + +// x^159808 mod p(x), x^159744 mod p(x) +DATA ·CastConst+1584(SB)/8, $0x0000000192db7f88 +DATA ·CastConst+1592(SB)/8, $0x000000016d5fa5fe + +// x^158784 mod p(x), x^158720 mod p(x) +DATA ·CastConst+1600(SB)/8, $0x000000018bf67b1e +DATA ·CastConst+1608(SB)/8, $0x00000001d0d2b9ca + +// x^157760 mod p(x), x^157696 mod p(x) +DATA ·CastConst+1616(SB)/8, $0x000000007c09163e +DATA ·CastConst+1624(SB)/8, $0x0000000041e7b470 + +// x^156736 mod p(x), x^156672 mod p(x) +DATA ·CastConst+1632(SB)/8, $0x000000000adac060 +DATA ·CastConst+1640(SB)/8, $0x00000001cbb6495e + +// x^155712 mod p(x), x^155648 mod p(x) +DATA ·CastConst+1648(SB)/8, $0x00000000bd8316ae +DATA ·CastConst+1656(SB)/8, $0x000000010052a0b0 + +// x^154688 mod p(x), x^154624 mod p(x) +DATA ·CastConst+1664(SB)/8, $0x000000019f09ab54 +DATA ·CastConst+1672(SB)/8, $0x00000001d8effb5c + +// x^153664 mod p(x), x^153600 mod p(x) +DATA ·CastConst+1680(SB)/8, $0x0000000125155542 +DATA ·CastConst+1688(SB)/8, $0x00000001d969853c + +// x^152640 mod p(x), x^152576 mod p(x) +DATA ·CastConst+1696(SB)/8, $0x000000018fdb5882 +DATA ·CastConst+1704(SB)/8, $0x00000000523ccce2 + +// x^151616 mod p(x), x^151552 mod p(x) +DATA ·CastConst+1712(SB)/8, $0x00000000e794b3f4 +DATA ·CastConst+1720(SB)/8, $0x000000001e2436bc + +// x^150592 mod p(x), x^150528 mod p(x) +DATA ·CastConst+1728(SB)/8, $0x000000016f9bb022 +DATA ·CastConst+1736(SB)/8, $0x00000000ddd1c3a2 + +// x^149568 mod p(x), x^149504 mod p(x) +DATA ·CastConst+1744(SB)/8, $0x00000000290c9978 +DATA ·CastConst+1752(SB)/8, $0x0000000019fcfe38 + +// x^148544 mod p(x), x^148480 mod p(x) +DATA ·CastConst+1760(SB)/8, $0x0000000083c0f350 +DATA ·CastConst+1768(SB)/8, $0x00000001ce95db64 + +// x^147520 mod p(x), x^147456 mod p(x) +DATA ·CastConst+1776(SB)/8, $0x0000000173ea6628 +DATA ·CastConst+1784(SB)/8, $0x00000000af582806 + +// x^146496 mod p(x), x^146432 mod p(x) +DATA ·CastConst+1792(SB)/8, $0x00000001c8b4e00a +DATA ·CastConst+1800(SB)/8, $0x00000001006388f6 + +// x^145472 mod p(x), x^145408 mod p(x) +DATA ·CastConst+1808(SB)/8, $0x00000000de95d6aa +DATA ·CastConst+1816(SB)/8, $0x0000000179eca00a + +// x^144448 mod p(x), x^144384 mod p(x) +DATA ·CastConst+1824(SB)/8, $0x000000010b7f7248 +DATA ·CastConst+1832(SB)/8, $0x0000000122410a6a + +// x^143424 mod p(x), x^143360 mod p(x) +DATA ·CastConst+1840(SB)/8, $0x00000001326e3a06 +DATA ·CastConst+1848(SB)/8, $0x000000004288e87c + +// x^142400 mod p(x), x^142336 mod p(x) +DATA ·CastConst+1856(SB)/8, $0x00000000bb62c2e6 +DATA ·CastConst+1864(SB)/8, $0x000000016c5490da + +// x^141376 mod p(x), x^141312 mod p(x) +DATA ·CastConst+1872(SB)/8, $0x0000000156a4b2c2 +DATA ·CastConst+1880(SB)/8, $0x00000000d1c71f6e + +// x^140352 mod p(x), x^140288 mod p(x) +DATA ·CastConst+1888(SB)/8, $0x000000011dfe763a +DATA ·CastConst+1896(SB)/8, $0x00000001b4ce08a6 + +// x^139328 mod p(x), x^139264 mod p(x) +DATA ·CastConst+1904(SB)/8, $0x000000007bcca8e2 +DATA ·CastConst+1912(SB)/8, $0x00000001466ba60c + +// x^138304 mod p(x), x^138240 mod p(x) +DATA ·CastConst+1920(SB)/8, $0x0000000186118faa +DATA ·CastConst+1928(SB)/8, $0x00000001f6c488a4 + +// x^137280 mod p(x), x^137216 mod p(x) +DATA ·CastConst+1936(SB)/8, $0x0000000111a65a88 +DATA ·CastConst+1944(SB)/8, $0x000000013bfb0682 + +// x^136256 mod p(x), x^136192 mod p(x) +DATA ·CastConst+1952(SB)/8, $0x000000003565e1c4 +DATA ·CastConst+1960(SB)/8, $0x00000000690e9e54 + +// x^135232 mod p(x), x^135168 mod p(x) +DATA ·CastConst+1968(SB)/8, $0x000000012ed02a82 +DATA ·CastConst+1976(SB)/8, $0x00000000281346b6 + +// x^134208 mod p(x), x^134144 mod p(x) +DATA ·CastConst+1984(SB)/8, $0x00000000c486ecfc +DATA ·CastConst+1992(SB)/8, $0x0000000156464024 + +// x^133184 mod p(x), x^133120 mod p(x) +DATA ·CastConst+2000(SB)/8, $0x0000000001b951b2 +DATA ·CastConst+2008(SB)/8, $0x000000016063a8dc + +// x^132160 mod p(x), x^132096 mod p(x) +DATA ·CastConst+2016(SB)/8, $0x0000000048143916 +DATA ·CastConst+2024(SB)/8, $0x0000000116a66362 + +// x^131136 mod p(x), x^131072 mod p(x) +DATA ·CastConst+2032(SB)/8, $0x00000001dc2ae124 +DATA ·CastConst+2040(SB)/8, $0x000000017e8aa4d2 + +// x^130112 mod p(x), x^130048 mod p(x) +DATA ·CastConst+2048(SB)/8, $0x00000001416c58d6 +DATA ·CastConst+2056(SB)/8, $0x00000001728eb10c + +// x^129088 mod p(x), x^129024 mod p(x) +DATA ·CastConst+2064(SB)/8, $0x00000000a479744a +DATA ·CastConst+2072(SB)/8, $0x00000001b08fd7fa + +// x^128064 mod p(x), x^128000 mod p(x) +DATA ·CastConst+2080(SB)/8, $0x0000000096ca3a26 +DATA ·CastConst+2088(SB)/8, $0x00000001092a16e8 + +// x^127040 mod p(x), x^126976 mod p(x) +DATA ·CastConst+2096(SB)/8, $0x00000000ff223d4e +DATA ·CastConst+2104(SB)/8, $0x00000000a505637c + +// x^126016 mod p(x), x^125952 mod p(x) +DATA ·CastConst+2112(SB)/8, $0x000000010e84da42 +DATA ·CastConst+2120(SB)/8, $0x00000000d94869b2 + +// x^124992 mod p(x), x^124928 mod p(x) +DATA ·CastConst+2128(SB)/8, $0x00000001b61ba3d0 +DATA ·CastConst+2136(SB)/8, $0x00000001c8b203ae + +// x^123968 mod p(x), x^123904 mod p(x) +DATA ·CastConst+2144(SB)/8, $0x00000000680f2de8 +DATA ·CastConst+2152(SB)/8, $0x000000005704aea0 + +// x^122944 mod p(x), x^122880 mod p(x) +DATA ·CastConst+2160(SB)/8, $0x000000008772a9a8 +DATA ·CastConst+2168(SB)/8, $0x000000012e295fa2 + +// x^121920 mod p(x), x^121856 mod p(x) +DATA ·CastConst+2176(SB)/8, $0x0000000155f295bc +DATA ·CastConst+2184(SB)/8, $0x000000011d0908bc + +// x^120896 mod p(x), x^120832 mod p(x) +DATA ·CastConst+2192(SB)/8, $0x00000000595f9282 +DATA ·CastConst+2200(SB)/8, $0x0000000193ed97ea + +// x^119872 mod p(x), x^119808 mod p(x) +DATA ·CastConst+2208(SB)/8, $0x0000000164b1c25a +DATA ·CastConst+2216(SB)/8, $0x000000013a0f1c52 + +// x^118848 mod p(x), x^118784 mod p(x) +DATA ·CastConst+2224(SB)/8, $0x00000000fbd67c50 +DATA ·CastConst+2232(SB)/8, $0x000000010c2c40c0 + +// x^117824 mod p(x), x^117760 mod p(x) +DATA ·CastConst+2240(SB)/8, $0x0000000096076268 +DATA ·CastConst+2248(SB)/8, $0x00000000ff6fac3e + +// x^116800 mod p(x), x^116736 mod p(x) +DATA ·CastConst+2256(SB)/8, $0x00000001d288e4cc +DATA ·CastConst+2264(SB)/8, $0x000000017b3609c0 + +// x^115776 mod p(x), x^115712 mod p(x) +DATA ·CastConst+2272(SB)/8, $0x00000001eaac1bdc +DATA ·CastConst+2280(SB)/8, $0x0000000088c8c922 + +// x^114752 mod p(x), x^114688 mod p(x) +DATA ·CastConst+2288(SB)/8, $0x00000001f1ea39e2 +DATA ·CastConst+2296(SB)/8, $0x00000001751baae6 + +// x^113728 mod p(x), x^113664 mod p(x) +DATA ·CastConst+2304(SB)/8, $0x00000001eb6506fc +DATA ·CastConst+2312(SB)/8, $0x0000000107952972 + +// x^112704 mod p(x), x^112640 mod p(x) +DATA ·CastConst+2320(SB)/8, $0x000000010f806ffe +DATA ·CastConst+2328(SB)/8, $0x0000000162b00abe + +// x^111680 mod p(x), x^111616 mod p(x) +DATA ·CastConst+2336(SB)/8, $0x000000010408481e +DATA ·CastConst+2344(SB)/8, $0x000000000d7b404c + +// x^110656 mod p(x), x^110592 mod p(x) +DATA ·CastConst+2352(SB)/8, $0x0000000188260534 +DATA ·CastConst+2360(SB)/8, $0x00000000763b13d4 + +// x^109632 mod p(x), x^109568 mod p(x) +DATA ·CastConst+2368(SB)/8, $0x0000000058fc73e0 +DATA ·CastConst+2376(SB)/8, $0x00000000f6dc22d8 + +// x^108608 mod p(x), x^108544 mod p(x) +DATA ·CastConst+2384(SB)/8, $0x00000000391c59b8 +DATA ·CastConst+2392(SB)/8, $0x000000007daae060 + +// x^107584 mod p(x), x^107520 mod p(x) +DATA ·CastConst+2400(SB)/8, $0x000000018b638400 +DATA ·CastConst+2408(SB)/8, $0x000000013359ab7c + +// x^106560 mod p(x), x^106496 mod p(x) +DATA ·CastConst+2416(SB)/8, $0x000000011738f5c4 +DATA ·CastConst+2424(SB)/8, $0x000000008add438a + +// x^105536 mod p(x), x^105472 mod p(x) +DATA ·CastConst+2432(SB)/8, $0x000000008cf7c6da +DATA ·CastConst+2440(SB)/8, $0x00000001edbefdea + +// x^104512 mod p(x), x^104448 mod p(x) +DATA ·CastConst+2448(SB)/8, $0x00000001ef97fb16 +DATA ·CastConst+2456(SB)/8, $0x000000004104e0f8 + +// x^103488 mod p(x), x^103424 mod p(x) +DATA ·CastConst+2464(SB)/8, $0x0000000102130e20 +DATA ·CastConst+2472(SB)/8, $0x00000000b48a8222 + +// x^102464 mod p(x), x^102400 mod p(x) +DATA ·CastConst+2480(SB)/8, $0x00000000db968898 +DATA ·CastConst+2488(SB)/8, $0x00000001bcb46844 + +// x^101440 mod p(x), x^101376 mod p(x) +DATA ·CastConst+2496(SB)/8, $0x00000000b5047b5e +DATA ·CastConst+2504(SB)/8, $0x000000013293ce0a + +// x^100416 mod p(x), x^100352 mod p(x) +DATA ·CastConst+2512(SB)/8, $0x000000010b90fdb2 +DATA ·CastConst+2520(SB)/8, $0x00000001710d0844 + +// x^99392 mod p(x), x^99328 mod p(x) +DATA ·CastConst+2528(SB)/8, $0x000000004834a32e +DATA ·CastConst+2536(SB)/8, $0x0000000117907f6e + +// x^98368 mod p(x), x^98304 mod p(x) +DATA ·CastConst+2544(SB)/8, $0x0000000059c8f2b0 +DATA ·CastConst+2552(SB)/8, $0x0000000087ddf93e + +// x^97344 mod p(x), x^97280 mod p(x) +DATA ·CastConst+2560(SB)/8, $0x0000000122cec508 +DATA ·CastConst+2568(SB)/8, $0x000000005970e9b0 + +// x^96320 mod p(x), x^96256 mod p(x) +DATA ·CastConst+2576(SB)/8, $0x000000000a330cda +DATA ·CastConst+2584(SB)/8, $0x0000000185b2b7d0 + +// x^95296 mod p(x), x^95232 mod p(x) +DATA ·CastConst+2592(SB)/8, $0x000000014a47148c +DATA ·CastConst+2600(SB)/8, $0x00000001dcee0efc + +// x^94272 mod p(x), x^94208 mod p(x) +DATA ·CastConst+2608(SB)/8, $0x0000000042c61cb8 +DATA ·CastConst+2616(SB)/8, $0x0000000030da2722 + +// x^93248 mod p(x), x^93184 mod p(x) +DATA ·CastConst+2624(SB)/8, $0x0000000012fe6960 +DATA ·CastConst+2632(SB)/8, $0x000000012f925a18 + +// x^92224 mod p(x), x^92160 mod p(x) +DATA ·CastConst+2640(SB)/8, $0x00000000dbda2c20 +DATA ·CastConst+2648(SB)/8, $0x00000000dd2e357c + +// x^91200 mod p(x), x^91136 mod p(x) +DATA ·CastConst+2656(SB)/8, $0x000000011122410c +DATA ·CastConst+2664(SB)/8, $0x00000000071c80de + +// x^90176 mod p(x), x^90112 mod p(x) +DATA ·CastConst+2672(SB)/8, $0x00000000977b2070 +DATA ·CastConst+2680(SB)/8, $0x000000011513140a + +// x^89152 mod p(x), x^89088 mod p(x) +DATA ·CastConst+2688(SB)/8, $0x000000014050438e +DATA ·CastConst+2696(SB)/8, $0x00000001df876e8e + +// x^88128 mod p(x), x^88064 mod p(x) +DATA ·CastConst+2704(SB)/8, $0x0000000147c840e8 +DATA ·CastConst+2712(SB)/8, $0x000000015f81d6ce + +// x^87104 mod p(x), x^87040 mod p(x) +DATA ·CastConst+2720(SB)/8, $0x00000001cc7c88ce +DATA ·CastConst+2728(SB)/8, $0x000000019dd94dbe + +// x^86080 mod p(x), x^86016 mod p(x) +DATA ·CastConst+2736(SB)/8, $0x00000001476b35a4 +DATA ·CastConst+2744(SB)/8, $0x00000001373d206e + +// x^85056 mod p(x), x^84992 mod p(x) +DATA ·CastConst+2752(SB)/8, $0x000000013d52d508 +DATA ·CastConst+2760(SB)/8, $0x00000000668ccade + +// x^84032 mod p(x), x^83968 mod p(x) +DATA ·CastConst+2768(SB)/8, $0x000000008e4be32e +DATA ·CastConst+2776(SB)/8, $0x00000001b192d268 + +// x^83008 mod p(x), x^82944 mod p(x) +DATA ·CastConst+2784(SB)/8, $0x00000000024120fe +DATA ·CastConst+2792(SB)/8, $0x00000000e30f3a78 + +// x^81984 mod p(x), x^81920 mod p(x) +DATA ·CastConst+2800(SB)/8, $0x00000000ddecddb4 +DATA ·CastConst+2808(SB)/8, $0x000000010ef1f7bc + +// x^80960 mod p(x), x^80896 mod p(x) +DATA ·CastConst+2816(SB)/8, $0x00000000d4d403bc +DATA ·CastConst+2824(SB)/8, $0x00000001f5ac7380 + +// x^79936 mod p(x), x^79872 mod p(x) +DATA ·CastConst+2832(SB)/8, $0x00000001734b89aa +DATA ·CastConst+2840(SB)/8, $0x000000011822ea70 + +// x^78912 mod p(x), x^78848 mod p(x) +DATA ·CastConst+2848(SB)/8, $0x000000010e7a58d6 +DATA ·CastConst+2856(SB)/8, $0x00000000c3a33848 + +// x^77888 mod p(x), x^77824 mod p(x) +DATA ·CastConst+2864(SB)/8, $0x00000001f9f04e9c +DATA ·CastConst+2872(SB)/8, $0x00000001bd151c24 + +// x^76864 mod p(x), x^76800 mod p(x) +DATA ·CastConst+2880(SB)/8, $0x00000000b692225e +DATA ·CastConst+2888(SB)/8, $0x0000000056002d76 + +// x^75840 mod p(x), x^75776 mod p(x) +DATA ·CastConst+2896(SB)/8, $0x000000019b8d3f3e +DATA ·CastConst+2904(SB)/8, $0x000000014657c4f4 + +// x^74816 mod p(x), x^74752 mod p(x) +DATA ·CastConst+2912(SB)/8, $0x00000001a874f11e +DATA ·CastConst+2920(SB)/8, $0x0000000113742d7c + +// x^73792 mod p(x), x^73728 mod p(x) +DATA ·CastConst+2928(SB)/8, $0x000000010d5a4254 +DATA ·CastConst+2936(SB)/8, $0x000000019c5920ba + +// x^72768 mod p(x), x^72704 mod p(x) +DATA ·CastConst+2944(SB)/8, $0x00000000bbb2f5d6 +DATA ·CastConst+2952(SB)/8, $0x000000005216d2d6 + +// x^71744 mod p(x), x^71680 mod p(x) +DATA ·CastConst+2960(SB)/8, $0x0000000179cc0e36 +DATA ·CastConst+2968(SB)/8, $0x0000000136f5ad8a + +// x^70720 mod p(x), x^70656 mod p(x) +DATA ·CastConst+2976(SB)/8, $0x00000001dca1da4a +DATA ·CastConst+2984(SB)/8, $0x000000018b07beb6 + +// x^69696 mod p(x), x^69632 mod p(x) +DATA ·CastConst+2992(SB)/8, $0x00000000feb1a192 +DATA ·CastConst+3000(SB)/8, $0x00000000db1e93b0 + +// x^68672 mod p(x), x^68608 mod p(x) +DATA ·CastConst+3008(SB)/8, $0x00000000d1eeedd6 +DATA ·CastConst+3016(SB)/8, $0x000000000b96fa3a + +// x^67648 mod p(x), x^67584 mod p(x) +DATA ·CastConst+3024(SB)/8, $0x000000008fad9bb4 +DATA ·CastConst+3032(SB)/8, $0x00000001d9968af0 + +// x^66624 mod p(x), x^66560 mod p(x) +DATA ·CastConst+3040(SB)/8, $0x00000001884938e4 +DATA ·CastConst+3048(SB)/8, $0x000000000e4a77a2 + +// x^65600 mod p(x), x^65536 mod p(x) +DATA ·CastConst+3056(SB)/8, $0x00000001bc2e9bc0 +DATA ·CastConst+3064(SB)/8, $0x00000000508c2ac8 + +// x^64576 mod p(x), x^64512 mod p(x) +DATA ·CastConst+3072(SB)/8, $0x00000001f9658a68 +DATA ·CastConst+3080(SB)/8, $0x0000000021572a80 + +// x^63552 mod p(x), x^63488 mod p(x) +DATA ·CastConst+3088(SB)/8, $0x000000001b9224fc +DATA ·CastConst+3096(SB)/8, $0x00000001b859daf2 + +// x^62528 mod p(x), x^62464 mod p(x) +DATA ·CastConst+3104(SB)/8, $0x0000000055b2fb84 +DATA ·CastConst+3112(SB)/8, $0x000000016f788474 + +// x^61504 mod p(x), x^61440 mod p(x) +DATA ·CastConst+3120(SB)/8, $0x000000018b090348 +DATA ·CastConst+3128(SB)/8, $0x00000001b438810e + +// x^60480 mod p(x), x^60416 mod p(x) +DATA ·CastConst+3136(SB)/8, $0x000000011ccbd5ea +DATA ·CastConst+3144(SB)/8, $0x0000000095ddc6f2 + +// x^59456 mod p(x), x^59392 mod p(x) +DATA ·CastConst+3152(SB)/8, $0x0000000007ae47f8 +DATA ·CastConst+3160(SB)/8, $0x00000001d977c20c + +// x^58432 mod p(x), x^58368 mod p(x) +DATA ·CastConst+3168(SB)/8, $0x0000000172acbec0 +DATA ·CastConst+3176(SB)/8, $0x00000000ebedb99a + +// x^57408 mod p(x), x^57344 mod p(x) +DATA ·CastConst+3184(SB)/8, $0x00000001c6e3ff20 +DATA ·CastConst+3192(SB)/8, $0x00000001df9e9e92 + +// x^56384 mod p(x), x^56320 mod p(x) +DATA ·CastConst+3200(SB)/8, $0x00000000e1b38744 +DATA ·CastConst+3208(SB)/8, $0x00000001a4a3f952 + +// x^55360 mod p(x), x^55296 mod p(x) +DATA ·CastConst+3216(SB)/8, $0x00000000791585b2 +DATA ·CastConst+3224(SB)/8, $0x00000000e2f51220 + +// x^54336 mod p(x), x^54272 mod p(x) +DATA ·CastConst+3232(SB)/8, $0x00000000ac53b894 +DATA ·CastConst+3240(SB)/8, $0x000000004aa01f3e + +// x^53312 mod p(x), x^53248 mod p(x) +DATA ·CastConst+3248(SB)/8, $0x00000001ed5f2cf4 +DATA ·CastConst+3256(SB)/8, $0x00000000b3e90a58 + +// x^52288 mod p(x), x^52224 mod p(x) +DATA ·CastConst+3264(SB)/8, $0x00000001df48b2e0 +DATA ·CastConst+3272(SB)/8, $0x000000000c9ca2aa + +// x^51264 mod p(x), x^51200 mod p(x) +DATA ·CastConst+3280(SB)/8, $0x00000000049c1c62 +DATA ·CastConst+3288(SB)/8, $0x0000000151682316 + +// x^50240 mod p(x), x^50176 mod p(x) +DATA ·CastConst+3296(SB)/8, $0x000000017c460c12 +DATA ·CastConst+3304(SB)/8, $0x0000000036fce78c + +// x^49216 mod p(x), x^49152 mod p(x) +DATA ·CastConst+3312(SB)/8, $0x000000015be4da7e +DATA ·CastConst+3320(SB)/8, $0x000000009037dc10 + +// x^48192 mod p(x), x^48128 mod p(x) +DATA ·CastConst+3328(SB)/8, $0x000000010f38f668 +DATA ·CastConst+3336(SB)/8, $0x00000000d3298582 + +// x^47168 mod p(x), x^47104 mod p(x) +DATA ·CastConst+3344(SB)/8, $0x0000000039f40a00 +DATA ·CastConst+3352(SB)/8, $0x00000001b42e8ad6 + +// x^46144 mod p(x), x^46080 mod p(x) +DATA ·CastConst+3360(SB)/8, $0x00000000bd4c10c4 +DATA ·CastConst+3368(SB)/8, $0x00000000142a9838 + +// x^45120 mod p(x), x^45056 mod p(x) +DATA ·CastConst+3376(SB)/8, $0x0000000042db1d98 +DATA ·CastConst+3384(SB)/8, $0x0000000109c7f190 + +// x^44096 mod p(x), x^44032 mod p(x) +DATA ·CastConst+3392(SB)/8, $0x00000001c905bae6 +DATA ·CastConst+3400(SB)/8, $0x0000000056ff9310 + +// x^43072 mod p(x), x^43008 mod p(x) +DATA ·CastConst+3408(SB)/8, $0x00000000069d40ea +DATA ·CastConst+3416(SB)/8, $0x00000001594513aa + +// x^42048 mod p(x), x^41984 mod p(x) +DATA ·CastConst+3424(SB)/8, $0x000000008e4fbad0 +DATA ·CastConst+3432(SB)/8, $0x00000001e3b5b1e8 + +// x^41024 mod p(x), x^40960 mod p(x) +DATA ·CastConst+3440(SB)/8, $0x0000000047bedd46 +DATA ·CastConst+3448(SB)/8, $0x000000011dd5fc08 + +// x^40000 mod p(x), x^39936 mod p(x) +DATA ·CastConst+3456(SB)/8, $0x0000000026396bf8 +DATA ·CastConst+3464(SB)/8, $0x00000001675f0cc2 + +// x^38976 mod p(x), x^38912 mod p(x) +DATA ·CastConst+3472(SB)/8, $0x00000000379beb92 +DATA ·CastConst+3480(SB)/8, $0x00000000d1c8dd44 + +// x^37952 mod p(x), x^37888 mod p(x) +DATA ·CastConst+3488(SB)/8, $0x000000000abae54a +DATA ·CastConst+3496(SB)/8, $0x0000000115ebd3d8 + +// x^36928 mod p(x), x^36864 mod p(x) +DATA ·CastConst+3504(SB)/8, $0x0000000007e6a128 +DATA ·CastConst+3512(SB)/8, $0x00000001ecbd0dac + +// x^35904 mod p(x), x^35840 mod p(x) +DATA ·CastConst+3520(SB)/8, $0x000000000ade29d2 +DATA ·CastConst+3528(SB)/8, $0x00000000cdf67af2 + +// x^34880 mod p(x), x^34816 mod p(x) +DATA ·CastConst+3536(SB)/8, $0x00000000f974c45c +DATA ·CastConst+3544(SB)/8, $0x000000004c01ff4c + +// x^33856 mod p(x), x^33792 mod p(x) +DATA ·CastConst+3552(SB)/8, $0x00000000e77ac60a +DATA ·CastConst+3560(SB)/8, $0x00000000f2d8657e + +// x^32832 mod p(x), x^32768 mod p(x) +DATA ·CastConst+3568(SB)/8, $0x0000000145895816 +DATA ·CastConst+3576(SB)/8, $0x000000006bae74c4 + +// x^31808 mod p(x), x^31744 mod p(x) +DATA ·CastConst+3584(SB)/8, $0x0000000038e362be +DATA ·CastConst+3592(SB)/8, $0x0000000152af8aa0 + +// x^30784 mod p(x), x^30720 mod p(x) +DATA ·CastConst+3600(SB)/8, $0x000000007f991a64 +DATA ·CastConst+3608(SB)/8, $0x0000000004663802 + +// x^29760 mod p(x), x^29696 mod p(x) +DATA ·CastConst+3616(SB)/8, $0x00000000fa366d3a +DATA ·CastConst+3624(SB)/8, $0x00000001ab2f5afc + +// x^28736 mod p(x), x^28672 mod p(x) +DATA ·CastConst+3632(SB)/8, $0x00000001a2bb34f0 +DATA ·CastConst+3640(SB)/8, $0x0000000074a4ebd4 + +// x^27712 mod p(x), x^27648 mod p(x) +DATA ·CastConst+3648(SB)/8, $0x0000000028a9981e +DATA ·CastConst+3656(SB)/8, $0x00000001d7ab3a4c + +// x^26688 mod p(x), x^26624 mod p(x) +DATA ·CastConst+3664(SB)/8, $0x00000001dbc672be +DATA ·CastConst+3672(SB)/8, $0x00000001a8da60c6 + +// x^25664 mod p(x), x^25600 mod p(x) +DATA ·CastConst+3680(SB)/8, $0x00000000b04d77f6 +DATA ·CastConst+3688(SB)/8, $0x000000013cf63820 + +// x^24640 mod p(x), x^24576 mod p(x) +DATA ·CastConst+3696(SB)/8, $0x0000000124400d96 +DATA ·CastConst+3704(SB)/8, $0x00000000bec12e1e + +// x^23616 mod p(x), x^23552 mod p(x) +DATA ·CastConst+3712(SB)/8, $0x000000014ca4b414 +DATA ·CastConst+3720(SB)/8, $0x00000001c6368010 + +// x^22592 mod p(x), x^22528 mod p(x) +DATA ·CastConst+3728(SB)/8, $0x000000012fe2c938 +DATA ·CastConst+3736(SB)/8, $0x00000001e6e78758 + +// x^21568 mod p(x), x^21504 mod p(x) +DATA ·CastConst+3744(SB)/8, $0x00000001faed01e6 +DATA ·CastConst+3752(SB)/8, $0x000000008d7f2b3c + +// x^20544 mod p(x), x^20480 mod p(x) +DATA ·CastConst+3760(SB)/8, $0x000000007e80ecfe +DATA ·CastConst+3768(SB)/8, $0x000000016b4a156e + +// x^19520 mod p(x), x^19456 mod p(x) +DATA ·CastConst+3776(SB)/8, $0x0000000098daee94 +DATA ·CastConst+3784(SB)/8, $0x00000001c63cfeb6 + +// x^18496 mod p(x), x^18432 mod p(x) +DATA ·CastConst+3792(SB)/8, $0x000000010a04edea +DATA ·CastConst+3800(SB)/8, $0x000000015f902670 + +// x^17472 mod p(x), x^17408 mod p(x) +DATA ·CastConst+3808(SB)/8, $0x00000001c00b4524 +DATA ·CastConst+3816(SB)/8, $0x00000001cd5de11e + +// x^16448 mod p(x), x^16384 mod p(x) +DATA ·CastConst+3824(SB)/8, $0x0000000170296550 +DATA ·CastConst+3832(SB)/8, $0x000000001acaec54 + +// x^15424 mod p(x), x^15360 mod p(x) +DATA ·CastConst+3840(SB)/8, $0x0000000181afaa48 +DATA ·CastConst+3848(SB)/8, $0x000000002bd0ca78 + +// x^14400 mod p(x), x^14336 mod p(x) +DATA ·CastConst+3856(SB)/8, $0x0000000185a31ffa +DATA ·CastConst+3864(SB)/8, $0x0000000032d63d5c + +// x^13376 mod p(x), x^13312 mod p(x) +DATA ·CastConst+3872(SB)/8, $0x000000002469f608 +DATA ·CastConst+3880(SB)/8, $0x000000001c6d4e4c + +// x^12352 mod p(x), x^12288 mod p(x) +DATA ·CastConst+3888(SB)/8, $0x000000006980102a +DATA ·CastConst+3896(SB)/8, $0x0000000106a60b92 + +// x^11328 mod p(x), x^11264 mod p(x) +DATA ·CastConst+3904(SB)/8, $0x0000000111ea9ca8 +DATA ·CastConst+3912(SB)/8, $0x00000000d3855e12 + +// x^10304 mod p(x), x^10240 mod p(x) +DATA ·CastConst+3920(SB)/8, $0x00000001bd1d29ce +DATA ·CastConst+3928(SB)/8, $0x00000000e3125636 + +// x^9280 mod p(x), x^9216 mod p(x) +DATA ·CastConst+3936(SB)/8, $0x00000001b34b9580 +DATA ·CastConst+3944(SB)/8, $0x000000009e8f7ea4 + +// x^8256 mod p(x), x^8192 mod p(x) +DATA ·CastConst+3952(SB)/8, $0x000000003076054e +DATA ·CastConst+3960(SB)/8, $0x00000001c82e562c + +// x^7232 mod p(x), x^7168 mod p(x) +DATA ·CastConst+3968(SB)/8, $0x000000012a608ea4 +DATA ·CastConst+3976(SB)/8, $0x00000000ca9f09ce + +// x^6208 mod p(x), x^6144 mod p(x) +DATA ·CastConst+3984(SB)/8, $0x00000000784d05fe +DATA ·CastConst+3992(SB)/8, $0x00000000c63764e6 + +// x^5184 mod p(x), x^5120 mod p(x) +DATA ·CastConst+4000(SB)/8, $0x000000016ef0d82a +DATA ·CastConst+4008(SB)/8, $0x0000000168d2e49e + +// x^4160 mod p(x), x^4096 mod p(x) +DATA ·CastConst+4016(SB)/8, $0x0000000075bda454 +DATA ·CastConst+4024(SB)/8, $0x00000000e986c148 + +// x^3136 mod p(x), x^3072 mod p(x) +DATA ·CastConst+4032(SB)/8, $0x000000003dc0a1c4 +DATA ·CastConst+4040(SB)/8, $0x00000000cfb65894 + +// x^2112 mod p(x), x^2048 mod p(x) +DATA ·CastConst+4048(SB)/8, $0x00000000e9a5d8be +DATA ·CastConst+4056(SB)/8, $0x0000000111cadee4 + +// x^1088 mod p(x), x^1024 mod p(x) +DATA ·CastConst+4064(SB)/8, $0x00000001609bc4b4 +DATA ·CastConst+4072(SB)/8, $0x0000000171fb63ce + +// x^2048 mod p(x), x^2016 mod p(x), x^1984 mod p(x), x^1952 mod p(x) +DATA ·CastConst+4080(SB)/8, $0x5cf015c388e56f72 +DATA ·CastConst+4088(SB)/8, $0x7fec2963e5bf8048 + +// x^1920 mod p(x), x^1888 mod p(x), x^1856 mod p(x), x^1824 mod p(x) +DATA ·CastConst+4096(SB)/8, $0x963a18920246e2e6 +DATA ·CastConst+4104(SB)/8, $0x38e888d4844752a9 + +// x^1792 mod p(x), x^1760 mod p(x), x^1728 mod p(x), x^1696 mod p(x) +DATA ·CastConst+4112(SB)/8, $0x419a441956993a31 +DATA ·CastConst+4120(SB)/8, $0x42316c00730206ad + +// x^1664 mod p(x), x^1632 mod p(x), x^1600 mod p(x), x^1568 mod p(x) +DATA ·CastConst+4128(SB)/8, $0x924752ba2b830011 +DATA ·CastConst+4136(SB)/8, $0x543d5c543e65ddf9 + +// x^1536 mod p(x), x^1504 mod p(x), x^1472 mod p(x), x^1440 mod p(x) +DATA ·CastConst+4144(SB)/8, $0x55bd7f9518e4a304 +DATA ·CastConst+4152(SB)/8, $0x78e87aaf56767c92 + +// x^1408 mod p(x), x^1376 mod p(x), x^1344 mod p(x), x^1312 mod p(x) +DATA ·CastConst+4160(SB)/8, $0x6d76739fe0553f1e +DATA ·CastConst+4168(SB)/8, $0x8f68fcec1903da7f + +// x^1280 mod p(x), x^1248 mod p(x), x^1216 mod p(x), x^1184 mod p(x) +DATA ·CastConst+4176(SB)/8, $0xc133722b1fe0b5c3 +DATA ·CastConst+4184(SB)/8, $0x3f4840246791d588 + +// x^1152 mod p(x), x^1120 mod p(x), x^1088 mod p(x), x^1056 mod p(x) +DATA ·CastConst+4192(SB)/8, $0x64b67ee0e55ef1f3 +DATA ·CastConst+4200(SB)/8, $0x34c96751b04de25a + +// x^1024 mod p(x), x^992 mod p(x), x^960 mod p(x), x^928 mod p(x) +DATA ·CastConst+4208(SB)/8, $0x069db049b8fdb1e7 +DATA ·CastConst+4216(SB)/8, $0x156c8e180b4a395b + +// x^896 mod p(x), x^864 mod p(x), x^832 mod p(x), x^800 mod p(x) +DATA ·CastConst+4224(SB)/8, $0xa11bfaf3c9e90b9e +DATA ·CastConst+4232(SB)/8, $0xe0b99ccbe661f7be + +// x^768 mod p(x), x^736 mod p(x), x^704 mod p(x), x^672 mod p(x) +DATA ·CastConst+4240(SB)/8, $0x817cdc5119b29a35 +DATA ·CastConst+4248(SB)/8, $0x041d37768cd75659 + +// x^640 mod p(x), x^608 mod p(x), x^576 mod p(x), x^544 mod p(x) +DATA ·CastConst+4256(SB)/8, $0x1ce9d94b36c41f1c +DATA ·CastConst+4264(SB)/8, $0x3a0777818cfaa965 + +// x^512 mod p(x), x^480 mod p(x), x^448 mod p(x), x^416 mod p(x) +DATA ·CastConst+4272(SB)/8, $0x4f256efcb82be955 +DATA ·CastConst+4280(SB)/8, $0x0e148e8252377a55 + +// x^384 mod p(x), x^352 mod p(x), x^320 mod p(x), x^288 mod p(x) +DATA ·CastConst+4288(SB)/8, $0xec1631edb2dea967 +DATA ·CastConst+4296(SB)/8, $0x9c25531d19e65dde + +// x^256 mod p(x), x^224 mod p(x), x^192 mod p(x), x^160 mod p(x) +DATA ·CastConst+4304(SB)/8, $0x5d27e147510ac59a +DATA ·CastConst+4312(SB)/8, $0x790606ff9957c0a6 + +// x^128 mod p(x), x^96 mod p(x), x^64 mod p(x), x^32 mod p(x) +DATA ·CastConst+4320(SB)/8, $0xa66805eb18b8ea18 +DATA ·CastConst+4328(SB)/8, $0x82f63b786ea2d55c + +GLOBL ·CastConst(SB), RODATA, $4336 + +// Barrett constant m - (4^32)/n +DATA ·CastBarConst(SB)/8, $0x00000000dea713f1 +DATA ·CastBarConst+8(SB)/8, $0x0000000000000000 +DATA ·CastBarConst+16(SB)/8, $0x0000000105ec76f1 +DATA ·CastBarConst+24(SB)/8, $0x0000000000000000 +GLOBL ·CastBarConst(SB), RODATA, $32 + +// Reduce 262144 kbits to 1024 bits +// x^261184 mod p(x), x^261120 mod p(x) +DATA ·KoopConst+0(SB)/8, $0x00000000d72535b2 +DATA ·KoopConst+8(SB)/8, $0x000000007fd74916 + +// x^260160 mod p(x), x^260096 mod p(x) +DATA ·KoopConst+16(SB)/8, $0x0000000118a2a1b4 +DATA ·KoopConst+24(SB)/8, $0x000000010e944b56 + +// x^259136 mod p(x), x^259072 mod p(x) +DATA ·KoopConst+32(SB)/8, $0x0000000147b5c49c +DATA ·KoopConst+40(SB)/8, $0x00000000bfe71c20 + +// x^258112 mod p(x), x^258048 mod p(x) +DATA ·KoopConst+48(SB)/8, $0x00000001ca76a040 +DATA ·KoopConst+56(SB)/8, $0x0000000021324d9a + +// x^257088 mod p(x), x^257024 mod p(x) +DATA ·KoopConst+64(SB)/8, $0x00000001e3152efc +DATA ·KoopConst+72(SB)/8, $0x00000000d20972ce + +// x^256064 mod p(x), x^256000 mod p(x) +DATA ·KoopConst+80(SB)/8, $0x00000001b0349792 +DATA ·KoopConst+88(SB)/8, $0x000000003475ea06 + +// x^255040 mod p(x), x^254976 mod p(x) +DATA ·KoopConst+96(SB)/8, $0x0000000120a60fe0 +DATA ·KoopConst+104(SB)/8, $0x00000001e40e36c4 + +// x^254016 mod p(x), x^253952 mod p(x) +DATA ·KoopConst+112(SB)/8, $0x00000000b3c4b082 +DATA ·KoopConst+120(SB)/8, $0x00000000b2490102 + +// x^252992 mod p(x), x^252928 mod p(x) +DATA ·KoopConst+128(SB)/8, $0x000000017fe9f3d2 +DATA ·KoopConst+136(SB)/8, $0x000000016b9e1332 + +// x^251968 mod p(x), x^251904 mod p(x) +DATA ·KoopConst+144(SB)/8, $0x0000000145703cbe +DATA ·KoopConst+152(SB)/8, $0x00000001d6c378f4 + +// x^250944 mod p(x), x^250880 mod p(x) +DATA ·KoopConst+160(SB)/8, $0x0000000107551c9c +DATA ·KoopConst+168(SB)/8, $0x0000000085796eac + +// x^249920 mod p(x), x^249856 mod p(x) +DATA ·KoopConst+176(SB)/8, $0x000000003865a702 +DATA ·KoopConst+184(SB)/8, $0x000000019d2f3aaa + +// x^248896 mod p(x), x^248832 mod p(x) +DATA ·KoopConst+192(SB)/8, $0x000000005504f9b8 +DATA ·KoopConst+200(SB)/8, $0x00000001554ddbd4 + +// x^247872 mod p(x), x^247808 mod p(x) +DATA ·KoopConst+208(SB)/8, $0x00000000239bcdd4 +DATA ·KoopConst+216(SB)/8, $0x00000000a76376b0 + +// x^246848 mod p(x), x^246784 mod p(x) +DATA ·KoopConst+224(SB)/8, $0x00000000caead774 +DATA ·KoopConst+232(SB)/8, $0x0000000139b7283c + +// x^245824 mod p(x), x^245760 mod p(x) +DATA ·KoopConst+240(SB)/8, $0x0000000022a3fa16 +DATA ·KoopConst+248(SB)/8, $0x0000000111087030 + +// x^244800 mod p(x), x^244736 mod p(x) +DATA ·KoopConst+256(SB)/8, $0x000000011f89160e +DATA ·KoopConst+264(SB)/8, $0x00000000ad786dc2 + +// x^243776 mod p(x), x^243712 mod p(x) +DATA ·KoopConst+272(SB)/8, $0x00000001a976c248 +DATA ·KoopConst+280(SB)/8, $0x00000000b7a1d068 + +// x^242752 mod p(x), x^242688 mod p(x) +DATA ·KoopConst+288(SB)/8, $0x00000000c20d09c8 +DATA ·KoopConst+296(SB)/8, $0x000000009c5c591c + +// x^241728 mod p(x), x^241664 mod p(x) +DATA ·KoopConst+304(SB)/8, $0x000000016264fe38 +DATA ·KoopConst+312(SB)/8, $0x000000016482aa1a + +// x^240704 mod p(x), x^240640 mod p(x) +DATA ·KoopConst+320(SB)/8, $0x00000001b57aee6a +DATA ·KoopConst+328(SB)/8, $0x000000009a409ba8 + +// x^239680 mod p(x), x^239616 mod p(x) +DATA ·KoopConst+336(SB)/8, $0x00000000e8f1be0a +DATA ·KoopConst+344(SB)/8, $0x00000001ad8eaed8 + +// x^238656 mod p(x), x^238592 mod p(x) +DATA ·KoopConst+352(SB)/8, $0x0000000053fcd0fc +DATA ·KoopConst+360(SB)/8, $0x000000017558b57a + +// x^237632 mod p(x), x^237568 mod p(x) +DATA ·KoopConst+368(SB)/8, $0x000000012df9d496 +DATA ·KoopConst+376(SB)/8, $0x00000000cbb749c8 + +// x^236608 mod p(x), x^236544 mod p(x) +DATA ·KoopConst+384(SB)/8, $0x000000004cb0db26 +DATA ·KoopConst+392(SB)/8, $0x000000008524fc5a + +// x^235584 mod p(x), x^235520 mod p(x) +DATA ·KoopConst+400(SB)/8, $0x00000001150c4584 +DATA ·KoopConst+408(SB)/8, $0x0000000028ce6b76 + +// x^234560 mod p(x), x^234496 mod p(x) +DATA ·KoopConst+416(SB)/8, $0x0000000104f52056 +DATA ·KoopConst+424(SB)/8, $0x00000000e0c48bdc + +// x^233536 mod p(x), x^233472 mod p(x) +DATA ·KoopConst+432(SB)/8, $0x000000008ea11ac8 +DATA ·KoopConst+440(SB)/8, $0x000000003dd3bf9a + +// x^232512 mod p(x), x^232448 mod p(x) +DATA ·KoopConst+448(SB)/8, $0x00000001cc0a3942 +DATA ·KoopConst+456(SB)/8, $0x00000000cb71066c + +// x^231488 mod p(x), x^231424 mod p(x) +DATA ·KoopConst+464(SB)/8, $0x00000000d26231e6 +DATA ·KoopConst+472(SB)/8, $0x00000001d4ee1540 + +// x^230464 mod p(x), x^230400 mod p(x) +DATA ·KoopConst+480(SB)/8, $0x00000000c70d5730 +DATA ·KoopConst+488(SB)/8, $0x00000001d82bed0a + +// x^229440 mod p(x), x^229376 mod p(x) +DATA ·KoopConst+496(SB)/8, $0x00000000e215dfc4 +DATA ·KoopConst+504(SB)/8, $0x000000016e0c7d86 + +// x^228416 mod p(x), x^228352 mod p(x) +DATA ·KoopConst+512(SB)/8, $0x000000013870d0dc +DATA ·KoopConst+520(SB)/8, $0x00000001437051b0 + +// x^227392 mod p(x), x^227328 mod p(x) +DATA ·KoopConst+528(SB)/8, $0x0000000153e4cf3c +DATA ·KoopConst+536(SB)/8, $0x00000000f9a8d4be + +// x^226368 mod p(x), x^226304 mod p(x) +DATA ·KoopConst+544(SB)/8, $0x0000000125f6fdf0 +DATA ·KoopConst+552(SB)/8, $0x000000016b09be1c + +// x^225344 mod p(x), x^225280 mod p(x) +DATA ·KoopConst+560(SB)/8, $0x0000000157ba3a82 +DATA ·KoopConst+568(SB)/8, $0x0000000105f50ed6 + +// x^224320 mod p(x), x^224256 mod p(x) +DATA ·KoopConst+576(SB)/8, $0x00000001cf711064 +DATA ·KoopConst+584(SB)/8, $0x00000001ca7fe3cc + +// x^223296 mod p(x), x^223232 mod p(x) +DATA ·KoopConst+592(SB)/8, $0x00000001006353d2 +DATA ·KoopConst+600(SB)/8, $0x0000000192372e78 + +// x^222272 mod p(x), x^222208 mod p(x) +DATA ·KoopConst+608(SB)/8, $0x000000010cd9faec +DATA ·KoopConst+616(SB)/8, $0x000000008a47af7e + +// x^221248 mod p(x), x^221184 mod p(x) +DATA ·KoopConst+624(SB)/8, $0x000000012148b190 +DATA ·KoopConst+632(SB)/8, $0x00000000a67473e8 + +// x^220224 mod p(x), x^220160 mod p(x) +DATA ·KoopConst+640(SB)/8, $0x00000000776473d6 +DATA ·KoopConst+648(SB)/8, $0x000000013689f2fa + +// x^219200 mod p(x), x^219136 mod p(x) +DATA ·KoopConst+656(SB)/8, $0x00000001ce765bd6 +DATA ·KoopConst+664(SB)/8, $0x00000000e7231774 + +// x^218176 mod p(x), x^218112 mod p(x) +DATA ·KoopConst+672(SB)/8, $0x00000000b29165e8 +DATA ·KoopConst+680(SB)/8, $0x0000000011b5ae68 + +// x^217152 mod p(x), x^217088 mod p(x) +DATA ·KoopConst+688(SB)/8, $0x0000000084ff5a68 +DATA ·KoopConst+696(SB)/8, $0x000000004fd5c188 + +// x^216128 mod p(x), x^216064 mod p(x) +DATA ·KoopConst+704(SB)/8, $0x00000001921e9076 +DATA ·KoopConst+712(SB)/8, $0x000000012148fa22 + +// x^215104 mod p(x), x^215040 mod p(x) +DATA ·KoopConst+720(SB)/8, $0x000000009a753a3c +DATA ·KoopConst+728(SB)/8, $0x000000010cff4f3e + +// x^214080 mod p(x), x^214016 mod p(x) +DATA ·KoopConst+736(SB)/8, $0x000000000251401e +DATA ·KoopConst+744(SB)/8, $0x00000001f9d991d4 + +// x^213056 mod p(x), x^212992 mod p(x) +DATA ·KoopConst+752(SB)/8, $0x00000001f65541fa +DATA ·KoopConst+760(SB)/8, $0x00000001c31db214 + +// x^212032 mod p(x), x^211968 mod p(x) +DATA ·KoopConst+768(SB)/8, $0x00000001d8c8117a +DATA ·KoopConst+776(SB)/8, $0x00000001849fba4a + +// x^211008 mod p(x), x^210944 mod p(x) +DATA ·KoopConst+784(SB)/8, $0x000000014f7a2200 +DATA ·KoopConst+792(SB)/8, $0x00000001cb603184 + +// x^209984 mod p(x), x^209920 mod p(x) +DATA ·KoopConst+800(SB)/8, $0x000000005154a9f4 +DATA ·KoopConst+808(SB)/8, $0x0000000132db7116 + +// x^208960 mod p(x), x^208896 mod p(x) +DATA ·KoopConst+816(SB)/8, $0x00000001dfc69196 +DATA ·KoopConst+824(SB)/8, $0x0000000010694e22 + +// x^207936 mod p(x), x^207872 mod p(x) +DATA ·KoopConst+832(SB)/8, $0x00000001c29f1aa0 +DATA ·KoopConst+840(SB)/8, $0x0000000103b7b478 + +// x^206912 mod p(x), x^206848 mod p(x) +DATA ·KoopConst+848(SB)/8, $0x000000013785f232 +DATA ·KoopConst+856(SB)/8, $0x000000000ab44030 + +// x^205888 mod p(x), x^205824 mod p(x) +DATA ·KoopConst+864(SB)/8, $0x000000010133536e +DATA ·KoopConst+872(SB)/8, $0x0000000131385b68 + +// x^204864 mod p(x), x^204800 mod p(x) +DATA ·KoopConst+880(SB)/8, $0x00000001d45421dc +DATA ·KoopConst+888(SB)/8, $0x00000001761dab66 + +// x^203840 mod p(x), x^203776 mod p(x) +DATA ·KoopConst+896(SB)/8, $0x000000000b59cc28 +DATA ·KoopConst+904(SB)/8, $0x000000012cf0a2a6 + +// x^202816 mod p(x), x^202752 mod p(x) +DATA ·KoopConst+912(SB)/8, $0x00000001f2f74aba +DATA ·KoopConst+920(SB)/8, $0x00000001f4ce25a2 + +// x^201792 mod p(x), x^201728 mod p(x) +DATA ·KoopConst+928(SB)/8, $0x00000000fb308e7e +DATA ·KoopConst+936(SB)/8, $0x000000014c2aae20 + +// x^200768 mod p(x), x^200704 mod p(x) +DATA ·KoopConst+944(SB)/8, $0x0000000167583fa6 +DATA ·KoopConst+952(SB)/8, $0x00000001c162a55a + +// x^199744 mod p(x), x^199680 mod p(x) +DATA ·KoopConst+960(SB)/8, $0x000000017ebb13e0 +DATA ·KoopConst+968(SB)/8, $0x0000000185681a40 + +// x^198720 mod p(x), x^198656 mod p(x) +DATA ·KoopConst+976(SB)/8, $0x00000001ca653306 +DATA ·KoopConst+984(SB)/8, $0x00000001f2642b48 + +// x^197696 mod p(x), x^197632 mod p(x) +DATA ·KoopConst+992(SB)/8, $0x0000000093bb6946 +DATA ·KoopConst+1000(SB)/8, $0x00000001d9cb5a78 + +// x^196672 mod p(x), x^196608 mod p(x) +DATA ·KoopConst+1008(SB)/8, $0x00000000cbc1553e +DATA ·KoopConst+1016(SB)/8, $0x000000008059328c + +// x^195648 mod p(x), x^195584 mod p(x) +DATA ·KoopConst+1024(SB)/8, $0x00000001f9a86fec +DATA ·KoopConst+1032(SB)/8, $0x000000009373c360 + +// x^194624 mod p(x), x^194560 mod p(x) +DATA ·KoopConst+1040(SB)/8, $0x0000000005c52d8a +DATA ·KoopConst+1048(SB)/8, $0x00000001a14061d6 + +// x^193600 mod p(x), x^193536 mod p(x) +DATA ·KoopConst+1056(SB)/8, $0x000000010d8dc668 +DATA ·KoopConst+1064(SB)/8, $0x00000000a9864d48 + +// x^192576 mod p(x), x^192512 mod p(x) +DATA ·KoopConst+1072(SB)/8, $0x0000000158571310 +DATA ·KoopConst+1080(SB)/8, $0x000000011df8c040 + +// x^191552 mod p(x), x^191488 mod p(x) +DATA ·KoopConst+1088(SB)/8, $0x0000000166102348 +DATA ·KoopConst+1096(SB)/8, $0x0000000023a3e6b6 + +// x^190528 mod p(x), x^190464 mod p(x) +DATA ·KoopConst+1104(SB)/8, $0x0000000009513050 +DATA ·KoopConst+1112(SB)/8, $0x00000001207db28a + +// x^189504 mod p(x), x^189440 mod p(x) +DATA ·KoopConst+1120(SB)/8, $0x00000000b0725c74 +DATA ·KoopConst+1128(SB)/8, $0x00000000f94bc632 + +// x^188480 mod p(x), x^188416 mod p(x) +DATA ·KoopConst+1136(SB)/8, $0x000000002985c7e2 +DATA ·KoopConst+1144(SB)/8, $0x00000000ea32cbf6 + +// x^187456 mod p(x), x^187392 mod p(x) +DATA ·KoopConst+1152(SB)/8, $0x00000000a7d4da9e +DATA ·KoopConst+1160(SB)/8, $0x0000000004eb981a + +// x^186432 mod p(x), x^186368 mod p(x) +DATA ·KoopConst+1168(SB)/8, $0x000000000a3f8792 +DATA ·KoopConst+1176(SB)/8, $0x00000000ca8ce712 + +// x^185408 mod p(x), x^185344 mod p(x) +DATA ·KoopConst+1184(SB)/8, $0x00000001ca2c1ce4 +DATA ·KoopConst+1192(SB)/8, $0x0000000065ba801c + +// x^184384 mod p(x), x^184320 mod p(x) +DATA ·KoopConst+1200(SB)/8, $0x00000000e2900196 +DATA ·KoopConst+1208(SB)/8, $0x0000000194aade7a + +// x^183360 mod p(x), x^183296 mod p(x) +DATA ·KoopConst+1216(SB)/8, $0x00000001fbadf0e4 +DATA ·KoopConst+1224(SB)/8, $0x00000001e7939fb2 + +// x^182336 mod p(x), x^182272 mod p(x) +DATA ·KoopConst+1232(SB)/8, $0x00000000d5d96c40 +DATA ·KoopConst+1240(SB)/8, $0x0000000098e5fe22 + +// x^181312 mod p(x), x^181248 mod p(x) +DATA ·KoopConst+1248(SB)/8, $0x000000015c11d3f2 +DATA ·KoopConst+1256(SB)/8, $0x000000016bba0324 + +// x^180288 mod p(x), x^180224 mod p(x) +DATA ·KoopConst+1264(SB)/8, $0x0000000111fb2648 +DATA ·KoopConst+1272(SB)/8, $0x0000000104dce052 + +// x^179264 mod p(x), x^179200 mod p(x) +DATA ·KoopConst+1280(SB)/8, $0x00000001d9f3a564 +DATA ·KoopConst+1288(SB)/8, $0x00000001af31a42e + +// x^178240 mod p(x), x^178176 mod p(x) +DATA ·KoopConst+1296(SB)/8, $0x00000001b556cd1e +DATA ·KoopConst+1304(SB)/8, $0x00000001c56c57ba + +// x^177216 mod p(x), x^177152 mod p(x) +DATA ·KoopConst+1312(SB)/8, $0x0000000101994d2c +DATA ·KoopConst+1320(SB)/8, $0x00000000f6bb1a2e + +// x^176192 mod p(x), x^176128 mod p(x) +DATA ·KoopConst+1328(SB)/8, $0x00000001e8dbf09c +DATA ·KoopConst+1336(SB)/8, $0x00000001abdbf2b2 + +// x^175168 mod p(x), x^175104 mod p(x) +DATA ·KoopConst+1344(SB)/8, $0x000000015580543a +DATA ·KoopConst+1352(SB)/8, $0x00000001a665a880 + +// x^174144 mod p(x), x^174080 mod p(x) +DATA ·KoopConst+1360(SB)/8, $0x00000000c7074f24 +DATA ·KoopConst+1368(SB)/8, $0x00000000c102c700 + +// x^173120 mod p(x), x^173056 mod p(x) +DATA ·KoopConst+1376(SB)/8, $0x00000000fa4112b0 +DATA ·KoopConst+1384(SB)/8, $0x00000000ee362a50 + +// x^172096 mod p(x), x^172032 mod p(x) +DATA ·KoopConst+1392(SB)/8, $0x00000000e786c13e +DATA ·KoopConst+1400(SB)/8, $0x0000000045f29038 + +// x^171072 mod p(x), x^171008 mod p(x) +DATA ·KoopConst+1408(SB)/8, $0x00000001e45e3694 +DATA ·KoopConst+1416(SB)/8, $0x0000000117b9ab5c + +// x^170048 mod p(x), x^169984 mod p(x) +DATA ·KoopConst+1424(SB)/8, $0x000000005423dd8c +DATA ·KoopConst+1432(SB)/8, $0x00000001115dff5e + +// x^169024 mod p(x), x^168960 mod p(x) +DATA ·KoopConst+1440(SB)/8, $0x00000001a1e67766 +DATA ·KoopConst+1448(SB)/8, $0x0000000117fad29c + +// x^168000 mod p(x), x^167936 mod p(x) +DATA ·KoopConst+1456(SB)/8, $0x0000000041a3f508 +DATA ·KoopConst+1464(SB)/8, $0x000000017de134e6 + +// x^166976 mod p(x), x^166912 mod p(x) +DATA ·KoopConst+1472(SB)/8, $0x000000003e792f7e +DATA ·KoopConst+1480(SB)/8, $0x00000000a2f5d19c + +// x^165952 mod p(x), x^165888 mod p(x) +DATA ·KoopConst+1488(SB)/8, $0x00000000c8948aaa +DATA ·KoopConst+1496(SB)/8, $0x00000000dee13658 + +// x^164928 mod p(x), x^164864 mod p(x) +DATA ·KoopConst+1504(SB)/8, $0x000000005d4ccb36 +DATA ·KoopConst+1512(SB)/8, $0x000000015355440c + +// x^163904 mod p(x), x^163840 mod p(x) +DATA ·KoopConst+1520(SB)/8, $0x00000000e92a78a2 +DATA ·KoopConst+1528(SB)/8, $0x0000000197a21778 + +// x^162880 mod p(x), x^162816 mod p(x) +DATA ·KoopConst+1536(SB)/8, $0x000000016ba67caa +DATA ·KoopConst+1544(SB)/8, $0x00000001a3835ec0 + +// x^161856 mod p(x), x^161792 mod p(x) +DATA ·KoopConst+1552(SB)/8, $0x000000004838afc6 +DATA ·KoopConst+1560(SB)/8, $0x0000000011f20912 + +// x^160832 mod p(x), x^160768 mod p(x) +DATA ·KoopConst+1568(SB)/8, $0x000000016644e308 +DATA ·KoopConst+1576(SB)/8, $0x00000001cce9d6cc + +// x^159808 mod p(x), x^159744 mod p(x) +DATA ·KoopConst+1584(SB)/8, $0x0000000037c22f42 +DATA ·KoopConst+1592(SB)/8, $0x0000000084d1e71c + +// x^158784 mod p(x), x^158720 mod p(x) +DATA ·KoopConst+1600(SB)/8, $0x00000001dedba6ca +DATA ·KoopConst+1608(SB)/8, $0x0000000197c2ad54 + +// x^157760 mod p(x), x^157696 mod p(x) +DATA ·KoopConst+1616(SB)/8, $0x0000000146a43500 +DATA ·KoopConst+1624(SB)/8, $0x000000018609261e + +// x^156736 mod p(x), x^156672 mod p(x) +DATA ·KoopConst+1632(SB)/8, $0x000000001cf762de +DATA ·KoopConst+1640(SB)/8, $0x00000000b4b4c224 + +// x^155712 mod p(x), x^155648 mod p(x) +DATA ·KoopConst+1648(SB)/8, $0x0000000022ff7eda +DATA ·KoopConst+1656(SB)/8, $0x0000000080817496 + +// x^154688 mod p(x), x^154624 mod p(x) +DATA ·KoopConst+1664(SB)/8, $0x00000001b6df625e +DATA ·KoopConst+1672(SB)/8, $0x00000001aefb473c + +// x^153664 mod p(x), x^153600 mod p(x) +DATA ·KoopConst+1680(SB)/8, $0x00000001cc99ab58 +DATA ·KoopConst+1688(SB)/8, $0x000000013f1aa474 + +// x^152640 mod p(x), x^152576 mod p(x) +DATA ·KoopConst+1696(SB)/8, $0x00000001c53f5ce2 +DATA ·KoopConst+1704(SB)/8, $0x000000010ca2c756 + +// x^151616 mod p(x), x^151552 mod p(x) +DATA ·KoopConst+1712(SB)/8, $0x0000000082a9c60e +DATA ·KoopConst+1720(SB)/8, $0x000000002c63533a + +// x^150592 mod p(x), x^150528 mod p(x) +DATA ·KoopConst+1728(SB)/8, $0x00000000ec78b570 +DATA ·KoopConst+1736(SB)/8, $0x00000001b7f2ad50 + +// x^149568 mod p(x), x^149504 mod p(x) +DATA ·KoopConst+1744(SB)/8, $0x00000001d3fe1e8e +DATA ·KoopConst+1752(SB)/8, $0x00000000acdf4c20 + +// x^148544 mod p(x), x^148480 mod p(x) +DATA ·KoopConst+1760(SB)/8, $0x000000007f9a7bde +DATA ·KoopConst+1768(SB)/8, $0x000000000bd29e8c + +// x^147520 mod p(x), x^147456 mod p(x) +DATA ·KoopConst+1776(SB)/8, $0x00000000e606f518 +DATA ·KoopConst+1784(SB)/8, $0x00000001eef6992e + +// x^146496 mod p(x), x^146432 mod p(x) +DATA ·KoopConst+1792(SB)/8, $0x000000008538cb96 +DATA ·KoopConst+1800(SB)/8, $0x00000000b01644e6 + +// x^145472 mod p(x), x^145408 mod p(x) +DATA ·KoopConst+1808(SB)/8, $0x0000000131d030b2 +DATA ·KoopConst+1816(SB)/8, $0x0000000059c51acc + +// x^144448 mod p(x), x^144384 mod p(x) +DATA ·KoopConst+1824(SB)/8, $0x00000000115a4d0e +DATA ·KoopConst+1832(SB)/8, $0x00000001a2849272 + +// x^143424 mod p(x), x^143360 mod p(x) +DATA ·KoopConst+1840(SB)/8, $0x00000000e8a5356e +DATA ·KoopConst+1848(SB)/8, $0x00000001a4e0b610 + +// x^142400 mod p(x), x^142336 mod p(x) +DATA ·KoopConst+1856(SB)/8, $0x0000000158d988be +DATA ·KoopConst+1864(SB)/8, $0x00000000084e81a6 + +// x^141376 mod p(x), x^141312 mod p(x) +DATA ·KoopConst+1872(SB)/8, $0x00000001240db498 +DATA ·KoopConst+1880(SB)/8, $0x00000001b71f1fd8 + +// x^140352 mod p(x), x^140288 mod p(x) +DATA ·KoopConst+1888(SB)/8, $0x000000009ce87826 +DATA ·KoopConst+1896(SB)/8, $0x000000017f7df380 + +// x^139328 mod p(x), x^139264 mod p(x) +DATA ·KoopConst+1904(SB)/8, $0x0000000021944aae +DATA ·KoopConst+1912(SB)/8, $0x00000001f7f4e190 + +// x^138304 mod p(x), x^138240 mod p(x) +DATA ·KoopConst+1920(SB)/8, $0x00000001cea3d67e +DATA ·KoopConst+1928(SB)/8, $0x0000000150220d86 + +// x^137280 mod p(x), x^137216 mod p(x) +DATA ·KoopConst+1936(SB)/8, $0x000000004434e926 +DATA ·KoopConst+1944(SB)/8, $0x00000001db7d2b2e + +// x^136256 mod p(x), x^136192 mod p(x) +DATA ·KoopConst+1952(SB)/8, $0x0000000011db8cbe +DATA ·KoopConst+1960(SB)/8, $0x00000000b6ba9668 + +// x^135232 mod p(x), x^135168 mod p(x) +DATA ·KoopConst+1968(SB)/8, $0x00000001f6e0b8dc +DATA ·KoopConst+1976(SB)/8, $0x0000000103fdcecc + +// x^134208 mod p(x), x^134144 mod p(x) +DATA ·KoopConst+1984(SB)/8, $0x00000001f163f4a0 +DATA ·KoopConst+1992(SB)/8, $0x0000000079816a22 + +// x^133184 mod p(x), x^133120 mod p(x) +DATA ·KoopConst+2000(SB)/8, $0x000000007b6cc60e +DATA ·KoopConst+2008(SB)/8, $0x0000000173483482 + +// x^132160 mod p(x), x^132096 mod p(x) +DATA ·KoopConst+2016(SB)/8, $0x000000000f26c82c +DATA ·KoopConst+2024(SB)/8, $0x00000000643ea4c0 + +// x^131136 mod p(x), x^131072 mod p(x) +DATA ·KoopConst+2032(SB)/8, $0x00000000b0acad80 +DATA ·KoopConst+2040(SB)/8, $0x00000000a64752d2 + +// x^130112 mod p(x), x^130048 mod p(x) +DATA ·KoopConst+2048(SB)/8, $0x000000013687e91c +DATA ·KoopConst+2056(SB)/8, $0x00000000ca98eb3a + +// x^129088 mod p(x), x^129024 mod p(x) +DATA ·KoopConst+2064(SB)/8, $0x000000006bac3a96 +DATA ·KoopConst+2072(SB)/8, $0x00000001ca6ac8f8 + +// x^128064 mod p(x), x^128000 mod p(x) +DATA ·KoopConst+2080(SB)/8, $0x00000001bf197d5c +DATA ·KoopConst+2088(SB)/8, $0x00000001c48e2e68 + +// x^127040 mod p(x), x^126976 mod p(x) +DATA ·KoopConst+2096(SB)/8, $0x00000000256e84f2 +DATA ·KoopConst+2104(SB)/8, $0x0000000070086782 + +// x^126016 mod p(x), x^125952 mod p(x) +DATA ·KoopConst+2112(SB)/8, $0x000000003eff0d16 +DATA ·KoopConst+2120(SB)/8, $0x00000000f763621c + +// x^124992 mod p(x), x^124928 mod p(x) +DATA ·KoopConst+2128(SB)/8, $0x00000001748e9fd2 +DATA ·KoopConst+2136(SB)/8, $0x00000000ba58646a + +// x^123968 mod p(x), x^123904 mod p(x) +DATA ·KoopConst+2144(SB)/8, $0x000000015bb85b42 +DATA ·KoopConst+2152(SB)/8, $0x0000000138e157d8 + +// x^122944 mod p(x), x^122880 mod p(x) +DATA ·KoopConst+2160(SB)/8, $0x0000000164d1a980 +DATA ·KoopConst+2168(SB)/8, $0x00000001bf0a09dc + +// x^121920 mod p(x), x^121856 mod p(x) +DATA ·KoopConst+2176(SB)/8, $0x000000001415c9f0 +DATA ·KoopConst+2184(SB)/8, $0x0000000098faf300 + +// x^120896 mod p(x), x^120832 mod p(x) +DATA ·KoopConst+2192(SB)/8, $0x0000000195ae2f48 +DATA ·KoopConst+2200(SB)/8, $0x00000001f872f2c6 + +// x^119872 mod p(x), x^119808 mod p(x) +DATA ·KoopConst+2208(SB)/8, $0x0000000059d1d81a +DATA ·KoopConst+2216(SB)/8, $0x00000000f92577be + +// x^118848 mod p(x), x^118784 mod p(x) +DATA ·KoopConst+2224(SB)/8, $0x00000001bf80257a +DATA ·KoopConst+2232(SB)/8, $0x00000001a4d975f4 + +// x^117824 mod p(x), x^117760 mod p(x) +DATA ·KoopConst+2240(SB)/8, $0x000000011e39bfce +DATA ·KoopConst+2248(SB)/8, $0x000000018b74eeca + +// x^116800 mod p(x), x^116736 mod p(x) +DATA ·KoopConst+2256(SB)/8, $0x00000001287a0456 +DATA ·KoopConst+2264(SB)/8, $0x00000000e8980404 + +// x^115776 mod p(x), x^115712 mod p(x) +DATA ·KoopConst+2272(SB)/8, $0x00000000a5eb589c +DATA ·KoopConst+2280(SB)/8, $0x0000000176ef2b74 + +// x^114752 mod p(x), x^114688 mod p(x) +DATA ·KoopConst+2288(SB)/8, $0x000000017d71c452 +DATA ·KoopConst+2296(SB)/8, $0x0000000063c85caa + +// x^113728 mod p(x), x^113664 mod p(x) +DATA ·KoopConst+2304(SB)/8, $0x00000000fa941f08 +DATA ·KoopConst+2312(SB)/8, $0x00000001708012cc + +// x^112704 mod p(x), x^112640 mod p(x) +DATA ·KoopConst+2320(SB)/8, $0x0000000064ea030e +DATA ·KoopConst+2328(SB)/8, $0x00000000474d58f6 + +// x^111680 mod p(x), x^111616 mod p(x) +DATA ·KoopConst+2336(SB)/8, $0x000000019b7cc7ba +DATA ·KoopConst+2344(SB)/8, $0x00000001c76085a6 + +// x^110656 mod p(x), x^110592 mod p(x) +DATA ·KoopConst+2352(SB)/8, $0x00000000225cb7ba +DATA ·KoopConst+2360(SB)/8, $0x000000018fb0681a + +// x^109632 mod p(x), x^109568 mod p(x) +DATA ·KoopConst+2368(SB)/8, $0x000000010ab3e1da +DATA ·KoopConst+2376(SB)/8, $0x00000001fcee1f16 + +// x^108608 mod p(x), x^108544 mod p(x) +DATA ·KoopConst+2384(SB)/8, $0x00000001ce5cc33e +DATA ·KoopConst+2392(SB)/8, $0x00000000cfbffb7c + +// x^107584 mod p(x), x^107520 mod p(x) +DATA ·KoopConst+2400(SB)/8, $0x000000005e980f6e +DATA ·KoopConst+2408(SB)/8, $0x000000017af8ee72 + +// x^106560 mod p(x), x^106496 mod p(x) +DATA ·KoopConst+2416(SB)/8, $0x00000000d3bf3f46 +DATA ·KoopConst+2424(SB)/8, $0x000000001c2ad3e2 + +// x^105536 mod p(x), x^105472 mod p(x) +DATA ·KoopConst+2432(SB)/8, $0x000000018d554ae0 +DATA ·KoopConst+2440(SB)/8, $0x00000000ee05450a + +// x^104512 mod p(x), x^104448 mod p(x) +DATA ·KoopConst+2448(SB)/8, $0x000000018e276eb0 +DATA ·KoopConst+2456(SB)/8, $0x000000000f7d5bac + +// x^103488 mod p(x), x^103424 mod p(x) +DATA ·KoopConst+2464(SB)/8, $0x000000001c0319ce +DATA ·KoopConst+2472(SB)/8, $0x00000001cb26e004 + +// x^102464 mod p(x), x^102400 mod p(x) +DATA ·KoopConst+2480(SB)/8, $0x00000001ca0c75ec +DATA ·KoopConst+2488(SB)/8, $0x00000001553314e2 + +// x^101440 mod p(x), x^101376 mod p(x) +DATA ·KoopConst+2496(SB)/8, $0x00000001fb075330 +DATA ·KoopConst+2504(SB)/8, $0x000000005729be2c + +// x^100416 mod p(x), x^100352 mod p(x) +DATA ·KoopConst+2512(SB)/8, $0x00000000677920e4 +DATA ·KoopConst+2520(SB)/8, $0x0000000192c4479c + +// x^99392 mod p(x), x^99328 mod p(x) +DATA ·KoopConst+2528(SB)/8, $0x00000000332247c8 +DATA ·KoopConst+2536(SB)/8, $0x0000000078d842b6 + +// x^98368 mod p(x), x^98304 mod p(x) +DATA ·KoopConst+2544(SB)/8, $0x00000000ef84fc6c +DATA ·KoopConst+2552(SB)/8, $0x0000000145ffa282 + +// x^97344 mod p(x), x^97280 mod p(x) +DATA ·KoopConst+2560(SB)/8, $0x0000000139ba7690 +DATA ·KoopConst+2568(SB)/8, $0x000000019d679bf4 + +// x^96320 mod p(x), x^96256 mod p(x) +DATA ·KoopConst+2576(SB)/8, $0x00000000029ef444 +DATA ·KoopConst+2584(SB)/8, $0x000000019412f7a0 + +// x^95296 mod p(x), x^95232 mod p(x) +DATA ·KoopConst+2592(SB)/8, $0x00000001d872048c +DATA ·KoopConst+2600(SB)/8, $0x00000000b28c5c96 + +// x^94272 mod p(x), x^94208 mod p(x) +DATA ·KoopConst+2608(SB)/8, $0x000000016535d70a +DATA ·KoopConst+2616(SB)/8, $0x00000000554bfd44 + +// x^93248 mod p(x), x^93184 mod p(x) +DATA ·KoopConst+2624(SB)/8, $0x00000000761dd222 +DATA ·KoopConst+2632(SB)/8, $0x00000000ce9cfa48 + +// x^92224 mod p(x), x^92160 mod p(x) +DATA ·KoopConst+2640(SB)/8, $0x00000001509a3a44 +DATA ·KoopConst+2648(SB)/8, $0x00000000a4702ab2 + +// x^91200 mod p(x), x^91136 mod p(x) +DATA ·KoopConst+2656(SB)/8, $0x000000007e7019f2 +DATA ·KoopConst+2664(SB)/8, $0x00000001c967fbee + +// x^90176 mod p(x), x^90112 mod p(x) +DATA ·KoopConst+2672(SB)/8, $0x00000000fb4c56ea +DATA ·KoopConst+2680(SB)/8, $0x00000000fd514b3e + +// x^89152 mod p(x), x^89088 mod p(x) +DATA ·KoopConst+2688(SB)/8, $0x000000012022e0ee +DATA ·KoopConst+2696(SB)/8, $0x00000001c0b6f95e + +// x^88128 mod p(x), x^88064 mod p(x) +DATA ·KoopConst+2704(SB)/8, $0x0000000004bc6054 +DATA ·KoopConst+2712(SB)/8, $0x0000000180e103ce + +// x^87104 mod p(x), x^87040 mod p(x) +DATA ·KoopConst+2720(SB)/8, $0x000000017a1a0030 +DATA ·KoopConst+2728(SB)/8, $0x00000001a1630916 + +// x^86080 mod p(x), x^86016 mod p(x) +DATA ·KoopConst+2736(SB)/8, $0x00000001c021a864 +DATA ·KoopConst+2744(SB)/8, $0x000000009a727fb2 + +// x^85056 mod p(x), x^84992 mod p(x) +DATA ·KoopConst+2752(SB)/8, $0x000000009c54421e +DATA ·KoopConst+2760(SB)/8, $0x00000000e83b081a + +// x^84032 mod p(x), x^83968 mod p(x) +DATA ·KoopConst+2768(SB)/8, $0x00000001b4e33e6a +DATA ·KoopConst+2776(SB)/8, $0x000000006b1a1f44 + +// x^83008 mod p(x), x^82944 mod p(x) +DATA ·KoopConst+2784(SB)/8, $0x000000015d615af0 +DATA ·KoopConst+2792(SB)/8, $0x00000000cf280394 + +// x^81984 mod p(x), x^81920 mod p(x) +DATA ·KoopConst+2800(SB)/8, $0x00000001914a3ba8 +DATA ·KoopConst+2808(SB)/8, $0x00000001154b8a9a + +// x^80960 mod p(x), x^80896 mod p(x) +DATA ·KoopConst+2816(SB)/8, $0x000000005f72ec44 +DATA ·KoopConst+2824(SB)/8, $0x0000000149ec63e2 + +// x^79936 mod p(x), x^79872 mod p(x) +DATA ·KoopConst+2832(SB)/8, $0x00000000a33746a8 +DATA ·KoopConst+2840(SB)/8, $0x000000018ef902c4 + +// x^78912 mod p(x), x^78848 mod p(x) +DATA ·KoopConst+2848(SB)/8, $0x00000001c91e90d4 +DATA ·KoopConst+2856(SB)/8, $0x0000000069addb88 + +// x^77888 mod p(x), x^77824 mod p(x) +DATA ·KoopConst+2864(SB)/8, $0x00000001052eb05e +DATA ·KoopConst+2872(SB)/8, $0x00000000e90a29ae + +// x^76864 mod p(x), x^76800 mod p(x) +DATA ·KoopConst+2880(SB)/8, $0x000000006a32f754 +DATA ·KoopConst+2888(SB)/8, $0x00000000c53641ae + +// x^75840 mod p(x), x^75776 mod p(x) +DATA ·KoopConst+2896(SB)/8, $0x00000001ecbd6436 +DATA ·KoopConst+2904(SB)/8, $0x00000000a17c3796 + +// x^74816 mod p(x), x^74752 mod p(x) +DATA ·KoopConst+2912(SB)/8, $0x000000000fd3f93a +DATA ·KoopConst+2920(SB)/8, $0x000000015307a62c + +// x^73792 mod p(x), x^73728 mod p(x) +DATA ·KoopConst+2928(SB)/8, $0x00000001686a4c24 +DATA ·KoopConst+2936(SB)/8, $0x000000002f94bbda + +// x^72768 mod p(x), x^72704 mod p(x) +DATA ·KoopConst+2944(SB)/8, $0x00000001e40afca0 +DATA ·KoopConst+2952(SB)/8, $0x0000000072c8b5e6 + +// x^71744 mod p(x), x^71680 mod p(x) +DATA ·KoopConst+2960(SB)/8, $0x000000012779a2b8 +DATA ·KoopConst+2968(SB)/8, $0x00000000f09b7424 + +// x^70720 mod p(x), x^70656 mod p(x) +DATA ·KoopConst+2976(SB)/8, $0x00000000dcdaeb9e +DATA ·KoopConst+2984(SB)/8, $0x00000001c57de3da + +// x^69696 mod p(x), x^69632 mod p(x) +DATA ·KoopConst+2992(SB)/8, $0x00000001674f7a2a +DATA ·KoopConst+3000(SB)/8, $0x000000013922b30e + +// x^68672 mod p(x), x^68608 mod p(x) +DATA ·KoopConst+3008(SB)/8, $0x00000000dcb9e846 +DATA ·KoopConst+3016(SB)/8, $0x000000008759a6c2 + +// x^67648 mod p(x), x^67584 mod p(x) +DATA ·KoopConst+3024(SB)/8, $0x00000000ea9a6af6 +DATA ·KoopConst+3032(SB)/8, $0x00000000545ae424 + +// x^66624 mod p(x), x^66560 mod p(x) +DATA ·KoopConst+3040(SB)/8, $0x000000006d1f7a74 +DATA ·KoopConst+3048(SB)/8, $0x00000001e0cbafd2 + +// x^65600 mod p(x), x^65536 mod p(x) +DATA ·KoopConst+3056(SB)/8, $0x000000006add215e +DATA ·KoopConst+3064(SB)/8, $0x0000000018360c04 + +// x^64576 mod p(x), x^64512 mod p(x) +DATA ·KoopConst+3072(SB)/8, $0x000000010a9ee4b0 +DATA ·KoopConst+3080(SB)/8, $0x00000000941dc432 + +// x^63552 mod p(x), x^63488 mod p(x) +DATA ·KoopConst+3088(SB)/8, $0x00000000304c48d2 +DATA ·KoopConst+3096(SB)/8, $0x0000000004d3566e + +// x^62528 mod p(x), x^62464 mod p(x) +DATA ·KoopConst+3104(SB)/8, $0x0000000163d0e672 +DATA ·KoopConst+3112(SB)/8, $0x0000000096aed14e + +// x^61504 mod p(x), x^61440 mod p(x) +DATA ·KoopConst+3120(SB)/8, $0x0000000010049166 +DATA ·KoopConst+3128(SB)/8, $0x0000000087c13618 + +// x^60480 mod p(x), x^60416 mod p(x) +DATA ·KoopConst+3136(SB)/8, $0x00000001d3913e34 +DATA ·KoopConst+3144(SB)/8, $0x00000001d52f7b0c + +// x^59456 mod p(x), x^59392 mod p(x) +DATA ·KoopConst+3152(SB)/8, $0x00000001e392d54a +DATA ·KoopConst+3160(SB)/8, $0x000000000182058e + +// x^58432 mod p(x), x^58368 mod p(x) +DATA ·KoopConst+3168(SB)/8, $0x0000000173f2704a +DATA ·KoopConst+3176(SB)/8, $0x00000001ed73aa02 + +// x^57408 mod p(x), x^57344 mod p(x) +DATA ·KoopConst+3184(SB)/8, $0x000000019112b480 +DATA ·KoopConst+3192(SB)/8, $0x000000002721a82e + +// x^56384 mod p(x), x^56320 mod p(x) +DATA ·KoopConst+3200(SB)/8, $0x0000000093d295d6 +DATA ·KoopConst+3208(SB)/8, $0x000000012ca83da2 + +// x^55360 mod p(x), x^55296 mod p(x) +DATA ·KoopConst+3216(SB)/8, $0x0000000114e37f44 +DATA ·KoopConst+3224(SB)/8, $0x00000000da358698 + +// x^54336 mod p(x), x^54272 mod p(x) +DATA ·KoopConst+3232(SB)/8, $0x00000000fcfebc86 +DATA ·KoopConst+3240(SB)/8, $0x0000000011fad322 + +// x^53312 mod p(x), x^53248 mod p(x) +DATA ·KoopConst+3248(SB)/8, $0x00000000834c48d6 +DATA ·KoopConst+3256(SB)/8, $0x000000012b25025c + +// x^52288 mod p(x), x^52224 mod p(x) +DATA ·KoopConst+3264(SB)/8, $0x000000017b909372 +DATA ·KoopConst+3272(SB)/8, $0x000000001290cd24 + +// x^51264 mod p(x), x^51200 mod p(x) +DATA ·KoopConst+3280(SB)/8, $0x000000010156b9ac +DATA ·KoopConst+3288(SB)/8, $0x000000016edd0b06 + +// x^50240 mod p(x), x^50176 mod p(x) +DATA ·KoopConst+3296(SB)/8, $0x0000000113a82fa8 +DATA ·KoopConst+3304(SB)/8, $0x00000000c08e222a + +// x^49216 mod p(x), x^49152 mod p(x) +DATA ·KoopConst+3312(SB)/8, $0x0000000182dacb74 +DATA ·KoopConst+3320(SB)/8, $0x00000000cfb4d10e + +// x^48192 mod p(x), x^48128 mod p(x) +DATA ·KoopConst+3328(SB)/8, $0x000000010210dc40 +DATA ·KoopConst+3336(SB)/8, $0x000000013e156ece + +// x^47168 mod p(x), x^47104 mod p(x) +DATA ·KoopConst+3344(SB)/8, $0x000000008ab5ed20 +DATA ·KoopConst+3352(SB)/8, $0x00000000f12d89f8 + +// x^46144 mod p(x), x^46080 mod p(x) +DATA ·KoopConst+3360(SB)/8, $0x00000000810386fa +DATA ·KoopConst+3368(SB)/8, $0x00000001fce3337c + +// x^45120 mod p(x), x^45056 mod p(x) +DATA ·KoopConst+3376(SB)/8, $0x000000011dce2fe2 +DATA ·KoopConst+3384(SB)/8, $0x00000001c4bf3514 + +// x^44096 mod p(x), x^44032 mod p(x) +DATA ·KoopConst+3392(SB)/8, $0x000000004bb0a390 +DATA ·KoopConst+3400(SB)/8, $0x00000001ae67c492 + +// x^43072 mod p(x), x^43008 mod p(x) +DATA ·KoopConst+3408(SB)/8, $0x00000000028d486a +DATA ·KoopConst+3416(SB)/8, $0x00000000302af704 + +// x^42048 mod p(x), x^41984 mod p(x) +DATA ·KoopConst+3424(SB)/8, $0x000000010e4d63fe +DATA ·KoopConst+3432(SB)/8, $0x00000001e375b250 + +// x^41024 mod p(x), x^40960 mod p(x) +DATA ·KoopConst+3440(SB)/8, $0x000000014fd6f458 +DATA ·KoopConst+3448(SB)/8, $0x00000001678b58c0 + +// x^40000 mod p(x), x^39936 mod p(x) +DATA ·KoopConst+3456(SB)/8, $0x00000000db7a83a2 +DATA ·KoopConst+3464(SB)/8, $0x0000000065103c1e + +// x^38976 mod p(x), x^38912 mod p(x) +DATA ·KoopConst+3472(SB)/8, $0x000000016cf9fa3c +DATA ·KoopConst+3480(SB)/8, $0x000000000ccd28ca + +// x^37952 mod p(x), x^37888 mod p(x) +DATA ·KoopConst+3488(SB)/8, $0x000000016bb33912 +DATA ·KoopConst+3496(SB)/8, $0x0000000059c177d4 + +// x^36928 mod p(x), x^36864 mod p(x) +DATA ·KoopConst+3504(SB)/8, $0x0000000135bda8bc +DATA ·KoopConst+3512(SB)/8, $0x00000001d162f83a + +// x^35904 mod p(x), x^35840 mod p(x) +DATA ·KoopConst+3520(SB)/8, $0x000000004e8c6b76 +DATA ·KoopConst+3528(SB)/8, $0x00000001efc0230c + +// x^34880 mod p(x), x^34816 mod p(x) +DATA ·KoopConst+3536(SB)/8, $0x00000000e17cb750 +DATA ·KoopConst+3544(SB)/8, $0x00000001a2a2e2d2 + +// x^33856 mod p(x), x^33792 mod p(x) +DATA ·KoopConst+3552(SB)/8, $0x000000010e8bb9cc +DATA ·KoopConst+3560(SB)/8, $0x00000001145c9dc2 + +// x^32832 mod p(x), x^32768 mod p(x) +DATA ·KoopConst+3568(SB)/8, $0x00000001859d1cae +DATA ·KoopConst+3576(SB)/8, $0x00000000949e4a48 + +// x^31808 mod p(x), x^31744 mod p(x) +DATA ·KoopConst+3584(SB)/8, $0x0000000167802bbe +DATA ·KoopConst+3592(SB)/8, $0x0000000128beecbc + +// x^30784 mod p(x), x^30720 mod p(x) +DATA ·KoopConst+3600(SB)/8, $0x0000000086f5219c +DATA ·KoopConst+3608(SB)/8, $0x00000001ffc96ae4 + +// x^29760 mod p(x), x^29696 mod p(x) +DATA ·KoopConst+3616(SB)/8, $0x00000001349a4faa +DATA ·KoopConst+3624(SB)/8, $0x00000001ba81e0aa + +// x^28736 mod p(x), x^28672 mod p(x) +DATA ·KoopConst+3632(SB)/8, $0x000000007da3353e +DATA ·KoopConst+3640(SB)/8, $0x0000000104d7df14 + +// x^27712 mod p(x), x^27648 mod p(x) +DATA ·KoopConst+3648(SB)/8, $0x00000000440fba4e +DATA ·KoopConst+3656(SB)/8, $0x00000001c2ff8518 + +// x^26688 mod p(x), x^26624 mod p(x) +DATA ·KoopConst+3664(SB)/8, $0x00000000507aba70 +DATA ·KoopConst+3672(SB)/8, $0x00000000ba6d4708 + +// x^25664 mod p(x), x^25600 mod p(x) +DATA ·KoopConst+3680(SB)/8, $0x0000000015b578b6 +DATA ·KoopConst+3688(SB)/8, $0x00000001d49d4bba + +// x^24640 mod p(x), x^24576 mod p(x) +DATA ·KoopConst+3696(SB)/8, $0x0000000141633fb2 +DATA ·KoopConst+3704(SB)/8, $0x00000000d21247e6 + +// x^23616 mod p(x), x^23552 mod p(x) +DATA ·KoopConst+3712(SB)/8, $0x0000000178712680 +DATA ·KoopConst+3720(SB)/8, $0x0000000063b4004a + +// x^22592 mod p(x), x^22528 mod p(x) +DATA ·KoopConst+3728(SB)/8, $0x000000001404c194 +DATA ·KoopConst+3736(SB)/8, $0x0000000094f55d2c + +// x^21568 mod p(x), x^21504 mod p(x) +DATA ·KoopConst+3744(SB)/8, $0x00000000469dbe46 +DATA ·KoopConst+3752(SB)/8, $0x00000001ca68fe74 + +// x^20544 mod p(x), x^20480 mod p(x) +DATA ·KoopConst+3760(SB)/8, $0x00000000fb093fd8 +DATA ·KoopConst+3768(SB)/8, $0x00000001fd7d1b4c + +// x^19520 mod p(x), x^19456 mod p(x) +DATA ·KoopConst+3776(SB)/8, $0x00000000767a2bfe +DATA ·KoopConst+3784(SB)/8, $0x0000000055982d0c + +// x^18496 mod p(x), x^18432 mod p(x) +DATA ·KoopConst+3792(SB)/8, $0x00000001344e22bc +DATA ·KoopConst+3800(SB)/8, $0x00000000221553a6 + +// x^17472 mod p(x), x^17408 mod p(x) +DATA ·KoopConst+3808(SB)/8, $0x0000000161cd9978 +DATA ·KoopConst+3816(SB)/8, $0x000000013d9a153a + +// x^16448 mod p(x), x^16384 mod p(x) +DATA ·KoopConst+3824(SB)/8, $0x00000001d702e906 +DATA ·KoopConst+3832(SB)/8, $0x00000001cd108b3c + +// x^15424 mod p(x), x^15360 mod p(x) +DATA ·KoopConst+3840(SB)/8, $0x00000001c7db9908 +DATA ·KoopConst+3848(SB)/8, $0x00000001d0af0f4a + +// x^14400 mod p(x), x^14336 mod p(x) +DATA ·KoopConst+3856(SB)/8, $0x00000001665d025c +DATA ·KoopConst+3864(SB)/8, $0x00000001196cf0ec + +// x^13376 mod p(x), x^13312 mod p(x) +DATA ·KoopConst+3872(SB)/8, $0x000000012df97c0e +DATA ·KoopConst+3880(SB)/8, $0x00000001c88c9704 + +// x^12352 mod p(x), x^12288 mod p(x) +DATA ·KoopConst+3888(SB)/8, $0x000000006fed84da +DATA ·KoopConst+3896(SB)/8, $0x000000002013d300 + +// x^11328 mod p(x), x^11264 mod p(x) +DATA ·KoopConst+3904(SB)/8, $0x00000000b094146e +DATA ·KoopConst+3912(SB)/8, $0x00000001c458501e + +// x^10304 mod p(x), x^10240 mod p(x) +DATA ·KoopConst+3920(SB)/8, $0x00000001ceb518a6 +DATA ·KoopConst+3928(SB)/8, $0x000000003ce14802 + +// x^9280 mod p(x), x^9216 mod p(x) +DATA ·KoopConst+3936(SB)/8, $0x000000011f16db0a +DATA ·KoopConst+3944(SB)/8, $0x00000000bb72bb98 + +// x^8256 mod p(x), x^8192 mod p(x) +DATA ·KoopConst+3952(SB)/8, $0x00000001d4aa130e +DATA ·KoopConst+3960(SB)/8, $0x00000000fb9aeaba + +// x^7232 mod p(x), x^7168 mod p(x) +DATA ·KoopConst+3968(SB)/8, $0x00000001991f01d2 +DATA ·KoopConst+3976(SB)/8, $0x000000000131f5e6 + +// x^6208 mod p(x), x^6144 mod p(x) +DATA ·KoopConst+3984(SB)/8, $0x000000006bd58b4c +DATA ·KoopConst+3992(SB)/8, $0x0000000089d5799a + +// x^5184 mod p(x), x^5120 mod p(x) +DATA ·KoopConst+4000(SB)/8, $0x000000007272c166 +DATA ·KoopConst+4008(SB)/8, $0x00000000474c43b0 + +// x^4160 mod p(x), x^4096 mod p(x) +DATA ·KoopConst+4016(SB)/8, $0x000000013974e6f8 +DATA ·KoopConst+4024(SB)/8, $0x00000001db991f34 + +// x^3136 mod p(x), x^3072 mod p(x) +DATA ·KoopConst+4032(SB)/8, $0x000000000bd6e03c +DATA ·KoopConst+4040(SB)/8, $0x000000004b1bfd00 + +// x^2112 mod p(x), x^2048 mod p(x) +DATA ·KoopConst+4048(SB)/8, $0x000000005988c652 +DATA ·KoopConst+4056(SB)/8, $0x000000004036b796 + +// x^1088 mod p(x), x^1024 mod p(x) +DATA ·KoopConst+4064(SB)/8, $0x00000000129ef036 +DATA ·KoopConst+4072(SB)/8, $0x000000000c5ec3d4 + +// x^2048 mod p(x), x^2016 mod p(x), x^1984 mod p(x), x^1952 mod p(x) +DATA ·KoopConst+4080(SB)/8, $0xd6f94847201b5bcb +DATA ·KoopConst+4088(SB)/8, $0x1efc02e79571e892 + +// x^1920 mod p(x), x^1888 mod p(x), x^1856 mod p(x), x^1824 mod p(x) +DATA ·KoopConst+4096(SB)/8, $0xce08adcc294c1393 +DATA ·KoopConst+4104(SB)/8, $0x0b269b5c5ab5f161 + +// x^1792 mod p(x), x^1760 mod p(x), x^1728 mod p(x), x^1696 mod p(x) +DATA ·KoopConst+4112(SB)/8, $0x17315505e4201e72 +DATA ·KoopConst+4120(SB)/8, $0x2e841f4784acf3e9 + +// x^1664 mod p(x), x^1632 mod p(x), x^1600 mod p(x), x^1568 mod p(x) +DATA ·KoopConst+4128(SB)/8, $0x37cfc3a67cc667e3 +DATA ·KoopConst+4136(SB)/8, $0x7020425856bc424b + +// x^1536 mod p(x), x^1504 mod p(x), x^1472 mod p(x), x^1440 mod p(x) +DATA ·KoopConst+4144(SB)/8, $0x8e2fa3369218d2c3 +DATA ·KoopConst+4152(SB)/8, $0xdf81bf923f7c6ef1 + +// x^1408 mod p(x), x^1376 mod p(x), x^1344 mod p(x), x^1312 mod p(x) +DATA ·KoopConst+4160(SB)/8, $0x5ce20d2d39ed1981 +DATA ·KoopConst+4168(SB)/8, $0x9d0898a0af5ddc43 + +// x^1280 mod p(x), x^1248 mod p(x), x^1216 mod p(x), x^1184 mod p(x) +DATA ·KoopConst+4176(SB)/8, $0x6f7f4546ca081e03 +DATA ·KoopConst+4184(SB)/8, $0x4992836903fda047 + +// x^1152 mod p(x), x^1120 mod p(x), x^1088 mod p(x), x^1056 mod p(x) +DATA ·KoopConst+4192(SB)/8, $0xfd4f413b9bf11d68 +DATA ·KoopConst+4200(SB)/8, $0xf4ddf452094f781b + +// x^1024 mod p(x), x^992 mod p(x), x^960 mod p(x), x^928 mod p(x) +DATA ·KoopConst+4208(SB)/8, $0x11d84204062f61ea +DATA ·KoopConst+4216(SB)/8, $0x9487f1e51f3588cf + +// x^896 mod p(x), x^864 mod p(x), x^832 mod p(x), x^800 mod p(x) +DATA ·KoopConst+4224(SB)/8, $0xfaedf111abf58a1f +DATA ·KoopConst+4232(SB)/8, $0x31da2c22b1384ec9 + +// x^768 mod p(x), x^736 mod p(x), x^704 mod p(x), x^672 mod p(x) +DATA ·KoopConst+4240(SB)/8, $0x0246b541e8f81b22 +DATA ·KoopConst+4248(SB)/8, $0xc857ede58a42eb47 + +// x^640 mod p(x), x^608 mod p(x), x^576 mod p(x), x^544 mod p(x) +DATA ·KoopConst+4256(SB)/8, $0xd4dbfa9b92b0372e +DATA ·KoopConst+4264(SB)/8, $0xe0354c0b2cd1c09a + +// x^512 mod p(x), x^480 mod p(x), x^448 mod p(x), x^416 mod p(x) +DATA ·KoopConst+4272(SB)/8, $0x5f36c79cfc4417ec +DATA ·KoopConst+4280(SB)/8, $0x4b92cf8d54b8f25b + +// x^384 mod p(x), x^352 mod p(x), x^320 mod p(x), x^288 mod p(x) +DATA ·KoopConst+4288(SB)/8, $0xdad234918345041e +DATA ·KoopConst+4296(SB)/8, $0x4e44c81828229301 + +// x^256 mod p(x), x^224 mod p(x), x^192 mod p(x), x^160 mod p(x) +DATA ·KoopConst+4304(SB)/8, $0x56fd28cc8e02f1d0 +DATA ·KoopConst+4312(SB)/8, $0x3da5e43c8ee9ee84 + +// x^128 mod p(x), x^96 mod p(x), x^64 mod p(x), x^32 mod p(x) +DATA ·KoopConst+4320(SB)/8, $0xa583017cdfcb9f08 +DATA ·KoopConst+4328(SB)/8, $0xeb31d82e0c62ab26 + +GLOBL ·KoopConst(SB), RODATA, $4336 + +// Barrett constant m - (4^32)/n +DATA ·KoopBarConst(SB)/8, $0x0000000017d232cd +DATA ·KoopBarConst+8(SB)/8, $0x0000000000000000 +DATA ·KoopBarConst+16(SB)/8, $0x00000001d663b05d +DATA ·KoopBarConst+24(SB)/8, $0x0000000000000000 +GLOBL ·KoopBarConst(SB), RODATA, $32 diff --git a/vendor/github.com/klauspost/crc32/gen.go b/vendor/github.com/klauspost/crc32/gen.go new file mode 100644 index 000000000..fb3040a7d --- /dev/null +++ b/vendor/github.com/klauspost/crc32/gen.go @@ -0,0 +1,7 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:generate go run gen_const_ppc64le.go + +package crc32 diff --git a/vendor/github.com/minio/crc64nvme/crc64.go b/vendor/github.com/minio/crc64nvme/crc64.go index 40ac28c76..ca34a48e0 100644 --- a/vendor/github.com/minio/crc64nvme/crc64.go +++ b/vendor/github.com/minio/crc64nvme/crc64.go @@ -125,14 +125,19 @@ func update(crc uint64, p []byte) uint64 { p = p[align:] } runs := len(p) / 128 - crc = updateAsm(crc, p[:128*runs]) + if hasAsm512 && runs >= 8 { + // Use 512-bit wide instructions for >= 1KB. + crc = updateAsm512(crc, p[:128*runs]) + } else { + crc = updateAsm(crc, p[:128*runs]) + } return update(crc, p[128*runs:]) } buildSlicing8TablesOnce() crc = ^crc // table comparison is somewhat expensive, so avoid it for small sizes - for len(p) >= 64 { + if len(p) >= 64 { var helperTable = slicing8TableNVME // Update using slicing-by-8 for len(p) > 8 { diff --git a/vendor/github.com/minio/crc64nvme/crc64_amd64.go b/vendor/github.com/minio/crc64nvme/crc64_amd64.go index fc8538bc3..c741591a6 100644 --- a/vendor/github.com/minio/crc64nvme/crc64_amd64.go +++ b/vendor/github.com/minio/crc64nvme/crc64_amd64.go @@ -11,5 +11,7 @@ import ( ) var hasAsm = cpuid.CPU.Supports(cpuid.SSE2, cpuid.CLMUL, cpuid.SSE4) +var hasAsm512 = cpuid.CPU.Supports(cpuid.AVX512F, cpuid.VPCLMULQDQ, cpuid.AVX512VL, cpuid.CLMUL) func updateAsm(crc uint64, p []byte) (checksum uint64) +func updateAsm512(crc uint64, p []byte) (checksum uint64) diff --git a/vendor/github.com/minio/crc64nvme/crc64_amd64.s b/vendor/github.com/minio/crc64nvme/crc64_amd64.s index 9782321fd..acfea6a15 100644 --- a/vendor/github.com/minio/crc64nvme/crc64_amd64.s +++ b/vendor/github.com/minio/crc64nvme/crc64_amd64.s @@ -155,3 +155,153 @@ skip128: NOTQ AX MOVQ AX, checksum+32(FP) RET + +// Constants, pre-splatted. +DATA ·asmConstantsPoly<>+0x00(SB)/8, $0xa1ca681e733f9c40 +DATA ·asmConstantsPoly<>+0x08(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x10(SB)/8, $0xa1ca681e733f9c40 +DATA ·asmConstantsPoly<>+0x18(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x20(SB)/8, $0xa1ca681e733f9c40 +DATA ·asmConstantsPoly<>+0x28(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x30(SB)/8, $0xa1ca681e733f9c40 +DATA ·asmConstantsPoly<>+0x38(SB)/8, $0 +// Upper +DATA ·asmConstantsPoly<>+0x40(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x48(SB)/8, $0x5f852fb61e8d92dc +DATA ·asmConstantsPoly<>+0x50(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x58(SB)/8, $0x5f852fb61e8d92dc +DATA ·asmConstantsPoly<>+0x60(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x68(SB)/8, $0x5f852fb61e8d92dc +DATA ·asmConstantsPoly<>+0x70(SB)/8, $0 +DATA ·asmConstantsPoly<>+0x78(SB)/8, $0x5f852fb61e8d92dc +GLOBL ·asmConstantsPoly<>(SB), (NOPTR+RODATA), $128 + +TEXT ·updateAsm512(SB), $0-40 + MOVQ crc+0(FP), AX // checksum + MOVQ p_base+8(FP), SI // start pointer + MOVQ p_len+16(FP), CX // length of buffer + NOTQ AX + SHRQ $7, CX + CMPQ CX, $1 + VPXORQ Z8, Z8, Z8 // Initialize ZMM8 to zero + JLT skip128 + + VMOVDQU64 0x00(SI), Z0 + VMOVDQU64 0x40(SI), Z4 + MOVQ $·asmConstantsPoly<>(SB), BX + VMOVQ AX, X8 + + // XOR initialization value into lower 64 bits of ZMM0 + VPXORQ Z8, Z0, Z0 + CMPQ CX, $1 + JE tail128 + + VMOVDQU64 0(BX), Z8 + VMOVDQU64 64(BX), Z9 + + PCALIGN $16 + +loop128: + VMOVDQU64 0x80(SI), Z1 + VMOVDQU64 0xc0(SI), Z5 + ADDQ $128, SI + + SUBQ $1, CX + VPCLMULQDQ $0x00, Z8, Z0, Z10 + VPCLMULQDQ $0x11, Z9, Z0, Z0 + VPTERNLOGD $0x96, Z1, Z10, Z0 // Combine results with xor into Z0 + + VPCLMULQDQ $0x00, Z8, Z4, Z10 + VPCLMULQDQ $0x11, Z9, Z4, Z4 + VPTERNLOGD $0x96, Z5, Z10, Z4 // Combine results with xor into Z4 + + CMPQ CX, $1 + JGT loop128 + +tail128: + // Extract X0 to X3 from ZMM0 + VEXTRACTF32X4 $1, Z0, X1 // X1: Second 128-bit lane + VEXTRACTF32X4 $2, Z0, X2 // X2: Third 128-bit lane + VEXTRACTF32X4 $3, Z0, X3 // X3: Fourth 128-bit lane + + // Extract X4 to X7 from ZMM4 + VEXTRACTF32X4 $1, Z4, X5 // X5: Second 128-bit lane + VEXTRACTF32X4 $2, Z4, X6 // X6: Third 128-bit lane + VEXTRACTF32X4 $3, Z4, X7 // X7: Fourth 128-bit lane + + MOVQ $0xd083dd594d96319d, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X0, X11 + MOVQ $0x946588403d4adcbc, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X0 + PXOR X11, X7 + PXOR X0, X7 + MOVQ $0x3c255f5ebc414423, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X1, X11 + MOVQ $0x34f5a24e22d66e90, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X1 + PXOR X11, X1 + PXOR X7, X1 + MOVQ $0x7b0ab10dd0f809fe, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X2, X11 + MOVQ $0x03363823e6e791e5, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X2 + PXOR X11, X2 + PXOR X1, X2 + MOVQ $0x0c32cdb31e18a84a, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X3, X11 + MOVQ $0x62242240ace5045a, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X3 + PXOR X11, X3 + PXOR X2, X3 + MOVQ $0xbdd7ac0ee1a4a0f0, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X4, X11 + MOVQ $0xa3ffdc1fe8e82a8b, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X4 + PXOR X11, X4 + PXOR X3, X4 + MOVQ $0xb0bc2e589204f500, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X5, X11 + MOVQ $0xe1e0bb9d45d7a44c, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X5 + PXOR X11, X5 + PXOR X4, X5 + MOVQ $0xeadc41fd2ba3d420, AX + MOVQ AX, X11 + PCLMULQDQ $0x00, X6, X11 + MOVQ $0x21e9761e252621ac, AX + PINSRQ $0x1, AX, X12 + PCLMULQDQ $0x11, X12, X6 + PXOR X11, X6 + PXOR X5, X6 + MOVQ AX, X5 + PCLMULQDQ $0x00, X6, X5 + PSHUFD $0xee, X6, X6 + PXOR X5, X6 + MOVQ $0x27ecfa329aef9f77, AX + MOVQ AX, X4 + PCLMULQDQ $0x00, X4, X6 + PEXTRQ $0, X6, BX + MOVQ $0x34d926535897936b, AX + MOVQ AX, X4 + PCLMULQDQ $0x00, X4, X6 + PXOR X5, X6 + PEXTRQ $1, X6, AX + XORQ BX, AX + +skip128: + NOTQ AX + MOVQ AX, checksum+32(FP) + VZEROUPPER + RET diff --git a/vendor/github.com/minio/crc64nvme/crc64_arm64.go b/vendor/github.com/minio/crc64nvme/crc64_arm64.go index 141ecf54d..7e3ea9134 100644 --- a/vendor/github.com/minio/crc64nvme/crc64_arm64.go +++ b/vendor/github.com/minio/crc64nvme/crc64_arm64.go @@ -11,5 +11,7 @@ import ( ) var hasAsm = cpuid.CPU.Supports(cpuid.ASIMD, cpuid.PMULL, cpuid.SHA3) +var hasAsm512 = false func updateAsm(crc uint64, p []byte) (checksum uint64) +func updateAsm512(crc uint64, p []byte) (checksum uint64) { panic("should not be reached") } diff --git a/vendor/github.com/minio/crc64nvme/crc64_other.go b/vendor/github.com/minio/crc64nvme/crc64_other.go index 467958c69..ae260f7fb 100644 --- a/vendor/github.com/minio/crc64nvme/crc64_other.go +++ b/vendor/github.com/minio/crc64nvme/crc64_other.go @@ -7,5 +7,7 @@ package crc64nvme var hasAsm = false +var hasAsm512 = false -func updateAsm(crc uint64, p []byte) (checksum uint64) { panic("should not be reached") } +func updateAsm(crc uint64, p []byte) (checksum uint64) { panic("should not be reached") } +func updateAsm512(crc uint64, p []byte) (checksum uint64) { panic("should not be reached") } diff --git a/vendor/github.com/minio/minio-go/v7/CLAUDE.md b/vendor/github.com/minio/minio-go/v7/CLAUDE.md new file mode 100644 index 000000000..26ff95323 --- /dev/null +++ b/vendor/github.com/minio/minio-go/v7/CLAUDE.md @@ -0,0 +1,125 @@ +CLAUDE.md +========= + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +Commands +-------- + +### Testing + +```bash +# Run all tests with race detection (requires MinIO server at localhost:9000) +SERVER_ENDPOINT=localhost:9000 ACCESS_KEY=minioadmin SECRET_KEY=minioadmin ENABLE_HTTPS=1 MINT_MODE=full go test -race -v ./... + +# Run tests without race detection +go test ./... + +# Run short tests only (no functional tests) +go test -short -race ./... + +# Run functional tests +go build -race functional_tests.go +SERVER_ENDPOINT=localhost:9000 ACCESS_KEY=minioadmin SECRET_KEY=minioadmin ENABLE_HTTPS=1 MINT_MODE=full ./functional_tests + +# Run functional tests without TLS +SERVER_ENDPOINT=localhost:9000 ACCESS_KEY=minioadmin SECRET_KEY=minioadmin ENABLE_HTTPS=0 MINT_MODE=full ./functional_tests +``` + +### Linting and Code Quality + +```bash +# Run all checks (lint, vet, test, examples, functional tests) +make checks + +# Run linter only +make lint + +# Run vet and staticcheck +make vet + +# Alternative: run golangci-lint directly +golangci-lint run --timeout=5m --config ./.golangci.yml +``` + +### Building Examples + +```bash +# Build all examples +make examples + +# Build a specific example +cd examples/s3 && go build -mod=mod putobject.go +``` + +Architecture +------------ + +### Core Client Structure + +The MinIO Go SDK is organized around a central `Client` struct (api.go:52) that implements Amazon S3 compatible methods. Key architectural patterns: + +1. **Modular API Organization**: API methods are split into logical files: + + - `api-bucket-*.go`: Bucket operations (lifecycle, encryption, versioning, etc.) + - `api-object-*.go`: Object operations (legal hold, retention, tagging, etc.) + - `api-get-*.go`, `api-put-*.go`: GET and PUT operations + - `api-list.go`: Listing operations + - `api-stat.go`: Status/info operations + +2. **Credential Management**: The `pkg/credentials/` package provides various credential providers: + + - Static credentials + - Environment variables (AWS/MinIO) + - IAM roles + - STS (Security Token Service) variants + - File-based credentials + - Chain provider for fallback mechanisms + +3. **Request Signing**: The `pkg/signer/` package handles AWS signature versions: + + - V2 signatures (legacy) + - V4 signatures (standard) + - Streaming signatures for large uploads + +4. **Transport Layer**: Custom HTTP transport with: + + - Retry logic with configurable max retries + - Health status monitoring + - Tracing support via httptrace + - Bucket location caching (`bucketLocCache`\) + - Session caching for credentials + +5. **Helper Packages**: + + - `pkg/encrypt/`: Server-side encryption utilities + - `pkg/notification/`: Event notification handling + - `pkg/policy/`: Bucket policy management + - `pkg/lifecycle/`: Object lifecycle rules + - `pkg/tags/`: Object and bucket tagging + - `pkg/s3utils/`: S3 utility functions + - `pkg/kvcache/`: Key-value caching + - `pkg/singleflight/`: Deduplication of concurrent requests + +### Testing Strategy + +- Unit tests alongside implementation files (`*_test.go`\) +- Comprehensive functional tests in `functional_tests.go` requiring a live MinIO server +- Example programs in `examples/` directory demonstrating API usage +- Build tag `//go:build mint` for integration tests + +### Error Handling + +- Custom error types in `api-error-response.go` +- HTTP status code mapping +- Retry logic for transient failures +- Detailed error context preservation + +Important Patterns +------------------ + +1. **Context Usage**: All API methods accept `context.Context` for cancellation and timeout control +2. **Options Pattern**: Methods use Options structs for optional parameters (e.g., `PutObjectOptions`, `GetObjectOptions`\) +3. **Streaming Support**: Large file operations use io.Reader/Writer interfaces for memory efficiency +4. **Bucket Lookup Types**: Supports both path-style and virtual-host-style S3 URLs +5. **MD5/SHA256 Hashing**: Configurable hash functions for integrity checks via `md5Hasher` and `sha256Hasher` diff --git a/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md b/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md index 24522ef75..e976dd6be 100644 --- a/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md +++ b/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md @@ -1,22 +1,23 @@ -### Developer Guidelines +### Developer Guidelines -``minio-go`` welcomes your contribution. To make the process as seamless as possible, we ask for the following: +`minio-go` welcomes your contribution. To make the process as seamless as possible, we ask for the following: -* Go ahead and fork the project and make your changes. We encourage pull requests to discuss code changes. - - Fork it - - Create your feature branch (git checkout -b my-new-feature) - - Commit your changes (git commit -am 'Add some feature') - - Push to the branch (git push origin my-new-feature) - - Create new Pull Request +- Go ahead and fork the project and make your changes. We encourage pull requests to discuss code changes. -* When you're ready to create a pull request, be sure to: - - Have test cases for the new code. If you have questions about how to do it, please ask in your pull request. - - Run `go fmt` - - Squash your commits into a single commit. `git rebase -i`. It's okay to force update your pull request. - - Make sure `go test -race ./...` and `go build` completes. - NOTE: go test runs functional tests and requires you to have a AWS S3 account. Set them as environment variables - ``ACCESS_KEY`` and ``SECRET_KEY``. To run shorter version of the tests please use ``go test -short -race ./...`` + - Fork it + - Create your feature branch (git checkout -b my-new-feature) + - Commit your changes (git commit -am 'Add some feature') + - Push to the branch (git push origin my-new-feature) + - Create new Pull Request -* Read [Effective Go](https://github.com/golang/go/wiki/CodeReviewComments) article from Golang project - - `minio-go` project is strictly conformant with Golang style - - if you happen to observe offending code, please feel free to send a pull request +- When you're ready to create a pull request, be sure to: + + - Have test cases for the new code. If you have questions about how to do it, please ask in your pull request. + - Run `go fmt` + - Squash your commits into a single commit. `git rebase -i`. It's okay to force update your pull request. + - Make sure `go test -race ./...` and `go build` completes. NOTE: go test runs functional tests and requires you to have a AWS S3 account. Set them as environment variables`ACCESS_KEY` and `SECRET_KEY`. To run shorter version of the tests please use `go test -short -race ./...` + +- Read [Effective Go](https://github.com/golang/go/wiki/CodeReviewComments) article from Golang project + + - `minio-go` project is strictly conformant with Golang style + - if you happen to observe offending code, please feel free to send a pull request diff --git a/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md b/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md index f640dfb9f..9b189373f 100644 --- a/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md +++ b/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md @@ -1,11 +1,15 @@ -# For maintainers only +For maintainers only +==================== -## Responsibilities +Responsibilities +---------------- Please go through this link [Maintainer Responsibility](https://gist.github.com/abperiasamy/f4d9b31d3186bbd26522) ### Making new releases + Tag and sign your release commit, additionally this step requires you to have access to MinIO's trusted private key. + ```sh $ export GNUPGHOME=/media/${USER}/minio/trusted $ git tag -s 4.0.0 @@ -14,6 +18,7 @@ $ git push --tags ``` ### Update version + Once release has been made update `libraryVersion` constant in `api.go` to next to be released version. ```sh @@ -22,14 +27,17 @@ $ grep libraryVersion api.go ``` Commit your changes + ``` $ git commit -a -m "Update version for next release" --author "MinIO Trusted <trusted@min.io>" ``` ### Announce + Announce new release by adding release notes at https://github.com/minio/minio-go/releases from `trusted@min.io` account. Release notes requires two sections `highlights` and `changelog`. Highlights is a bulleted list of salient features in this release and Changelog contains list of all commits since the last release. To generate `changelog` + ```sh $ git log --no-color --pretty=format:'-%d %s (%cr) <%an>' <last_release_tag>..<latest_release_tag> ``` diff --git a/vendor/github.com/minio/minio-go/v7/README.md b/vendor/github.com/minio/minio-go/v7/README.md index be7963c52..36c1004c9 100644 --- a/vendor/github.com/minio/minio-go/v7/README.md +++ b/vendor/github.com/minio/minio-go/v7/README.md @@ -1,13 +1,14 @@ -# MinIO Go Client SDK for Amazon S3 Compatible Cloud Storage [](https://slack.min.io) [](https://sourcegraph.com/github.com/minio/minio-go?badge) [](https://github.com/minio/minio-go/blob/master/LICENSE) +MinIO Go Client SDK for Amazon S3 Compatible Cloud Storage [](https://slack.min.io) [](https://sourcegraph.com/github.com/minio/minio-go?badge) [](https://github.com/minio/minio-go/blob/master/LICENSE) +================================================================================================================================================================================================================================================================================================================================================================================================================== The MinIO Go Client SDK provides straightforward APIs to access any Amazon S3 compatible object storage. -This Quickstart Guide covers how to install the MinIO client SDK, connect to MinIO, and create a sample file uploader. -For a complete list of APIs and examples, see the [godoc documentation](https://pkg.go.dev/github.com/minio/minio-go/v7) or [Go Client API Reference](https://min.io/docs/minio/linux/developers/go/API.html). +This Quickstart Guide covers how to install the MinIO client SDK, connect to MinIO, and create a sample file uploader. For a complete list of APIs and examples, see the [godoc documentation](https://pkg.go.dev/github.com/minio/minio-go/v7) or [Go Client API Reference](https://min.io/docs/minio/linux/developers/go/API.html). These examples presume a working [Go development environment](https://golang.org/doc/install) and the [MinIO `mc` command line tool](https://min.io/docs/minio/linux/reference/minio-mc.html). -## Download from Github +Download from Github +-------------------- From your project directory: @@ -15,12 +16,13 @@ From your project directory: go get github.com/minio/minio-go/v7 ``` -## Initialize a MinIO Client Object +Initialize a MinIO Client Object +-------------------------------- The MinIO client requires the following parameters to connect to an Amazon S3 compatible object storage: | Parameter | Description | -| ----------------- | ---------------------------------------------------------- | +|-------------------|------------------------------------------------------------| | `endpoint` | URL to object storage service. | | `_minio.Options_` | All the options such as credentials, custom transport etc. | @@ -53,83 +55,82 @@ func main() { } ``` -## Example - File Uploader +Example - File Uploader +----------------------- -This sample code connects to an object storage server, creates a bucket, and uploads a file to the bucket. -It uses the MinIO `play` server, a public MinIO cluster located at [https://play.min.io](https://play.min.io). +This sample code connects to an object storage server, creates a bucket, and uploads a file to the bucket. It uses the MinIO `play` server, a public MinIO cluster located at [https://play.min.io](https://play.min.io). -The `play` server runs the latest stable version of MinIO and may be used for testing and development. -The access credentials shown in this example are open to the public and all data uploaded to `play` should be considered public and non-protected. +The `play` server runs the latest stable version of MinIO and may be used for testing and development. The access credentials shown in this example are open to the public and all data uploaded to `play` should be considered public and non-protected. ### FileUploader.go This example does the following: -- Connects to the MinIO `play` server using the provided credentials. -- Creates a bucket named `testbucket`. -- Uploads a file named `testdata` from `/tmp`. -- Verifies the file was created using `mc ls`. - -```go -// FileUploader.go MinIO example -package main - -import ( - "context" - "log" - - "github.com/minio/minio-go/v7" - "github.com/minio/minio-go/v7/pkg/credentials" -) - -func main() { - ctx := context.Background() - endpoint := "play.min.io" - accessKeyID := "Q3AM3UQ867SPQQA43P2F" - secretAccessKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG" - useSSL := true +- Connects to the MinIO `play` server using the provided credentials. +- Creates a bucket named `testbucket`. +- Uploads a file named `testdata` from `/tmp`. +- Verifies the file was created using `mc ls`. + + ```go + // FileUploader.go MinIO example + package main + + import ( + "context" + "log" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" + ) + + func main() { + ctx := context.Background() + endpoint := "play.min.io" + accessKeyID := "Q3AM3UQ867SPQQA43P2F" + secretAccessKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG" + useSSL := true + + // Initialize minio client object. + minioClient, err := minio.New(endpoint, &minio.Options{ + Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""), + Secure: useSSL, + }) + if err != nil { + log.Fatalln(err) + } - // Initialize minio client object. - minioClient, err := minio.New(endpoint, &minio.Options{ - Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""), - Secure: useSSL, - }) - if err != nil { - log.Fatalln(err) - } + // Make a new bucket called testbucket. + bucketName := "testbucket" + location := "us-east-1" + + err = minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{Region: location}) + if err != nil { + // Check to see if we already own this bucket (which happens if you run this twice) + exists, errBucketExists := minioClient.BucketExists(ctx, bucketName) + if errBucketExists == nil && exists { + log.Printf("We already own %s\n", bucketName) + } else { + log.Fatalln(err) + } + } else { + log.Printf("Successfully created %s\n", bucketName) + } - // Make a new bucket called testbucket. - bucketName := "testbucket" - location := "us-east-1" + // Upload the test file + // Change the value of filePath if the file is in another location + objectName := "testdata" + filePath := "/tmp/testdata" + contentType := "application/octet-stream" - err = minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{Region: location}) - if err != nil { - // Check to see if we already own this bucket (which happens if you run this twice) - exists, errBucketExists := minioClient.BucketExists(ctx, bucketName) - if errBucketExists == nil && exists { - log.Printf("We already own %s\n", bucketName) - } else { + // Upload the test file with FPutObject + info, err := minioClient.FPutObject(ctx, bucketName, objectName, filePath, minio.PutObjectOptions{ContentType: contentType}) + if err != nil { log.Fatalln(err) } - } else { - log.Printf("Successfully created %s\n", bucketName) - } - // Upload the test file - // Change the value of filePath if the file is in another location - objectName := "testdata" - filePath := "/tmp/testdata" - contentType := "application/octet-stream" - - // Upload the test file with FPutObject - info, err := minioClient.FPutObject(ctx, bucketName, objectName, filePath, minio.PutObjectOptions{ContentType: contentType}) - if err != nil { - log.Fatalln(err) + log.Printf("Successfully uploaded %s of size %d\n", objectName, info.Size) } - - log.Printf("Successfully uploaded %s of size %d\n", objectName, info.Size) -} -``` + ``` **1. Create a test file containing data:** @@ -168,145 +169,150 @@ mc ls play/testbucket [2023-11-01 14:27:55 UTC] 20KiB STANDARD TestDataFile ``` -## API Reference +API Reference +------------- The full API Reference is available here. -* [Complete API Reference](https://min.io/docs/minio/linux/developers/go/API.html) +- [Complete API Reference](https://min.io/docs/minio/linux/developers/go/API.html) ### API Reference : Bucket Operations -* [`MakeBucket`](https://min.io/docs/minio/linux/developers/go/API.html#MakeBucket) -* [`ListBuckets`](https://min.io/docs/minio/linux/developers/go/API.html#ListBuckets) -* [`BucketExists`](https://min.io/docs/minio/linux/developers/go/API.html#BucketExists) -* [`RemoveBucket`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveBucket) -* [`ListObjects`](https://min.io/docs/minio/linux/developers/go/API.html#ListObjects) -* [`ListIncompleteUploads`](https://min.io/docs/minio/linux/developers/go/API.html#ListIncompleteUploads) +- [`MakeBucket`](https://min.io/docs/minio/linux/developers/go/API.html#MakeBucket) +- [`ListBuckets`](https://min.io/docs/minio/linux/developers/go/API.html#ListBuckets) +- [`BucketExists`](https://min.io/docs/minio/linux/developers/go/API.html#BucketExists) +- [`RemoveBucket`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveBucket) +- [`ListObjects`](https://min.io/docs/minio/linux/developers/go/API.html#ListObjects) +- [`ListIncompleteUploads`](https://min.io/docs/minio/linux/developers/go/API.html#ListIncompleteUploads) ### API Reference : Bucket policy Operations -* [`SetBucketPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#SetBucketPolicy) -* [`GetBucketPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#GetBucketPolicy) +- [`SetBucketPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#SetBucketPolicy) +- [`GetBucketPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#GetBucketPolicy) ### API Reference : Bucket notification Operations -* [`SetBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#SetBucketNotification) -* [`GetBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#GetBucketNotification) -* [`RemoveAllBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveAllBucketNotification) -* [`ListenBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#ListenBucketNotification) (MinIO Extension) -* [`ListenNotification`](https://min.io/docs/minio/linux/developers/go/API.html#ListenNotification) (MinIO Extension) +- [`SetBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#SetBucketNotification) +- [`GetBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#GetBucketNotification) +- [`RemoveAllBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveAllBucketNotification) +- [`ListenBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#ListenBucketNotification) (MinIO Extension) +- [`ListenNotification`](https://min.io/docs/minio/linux/developers/go/API.html#ListenNotification) (MinIO Extension) ### API Reference : File Object Operations -* [`FPutObject`](https://min.io/docs/minio/linux/developers/go/API.html#FPutObject) -* [`FGetObject`](https://min.io/docs/minio/linux/developers/go/API.html#FGetObject) +- [`FPutObject`](https://min.io/docs/minio/linux/developers/go/API.html#FPutObject) +- [`FGetObject`](https://min.io/docs/minio/linux/developers/go/API.html#FGetObject) ### API Reference : Object Operations -* [`GetObject`](https://min.io/docs/minio/linux/developers/go/API.html#GetObject) -* [`PutObject`](https://min.io/docs/minio/linux/developers/go/API.html#PutObject) -* [`PutObjectStreaming`](https://min.io/docs/minio/linux/developers/go/API.html#PutObjectStreaming) -* [`StatObject`](https://min.io/docs/minio/linux/developers/go/API.html#StatObject) -* [`CopyObject`](https://min.io/docs/minio/linux/developers/go/API.html#CopyObject) -* [`RemoveObject`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveObject) -* [`RemoveObjects`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveObjects) -* [`RemoveIncompleteUpload`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveIncompleteUpload) -* [`SelectObjectContent`](https://min.io/docs/minio/linux/developers/go/API.html#SelectObjectContent) +- [`GetObject`](https://min.io/docs/minio/linux/developers/go/API.html#GetObject) +- [`PutObject`](https://min.io/docs/minio/linux/developers/go/API.html#PutObject) +- [`PutObjectStreaming`](https://min.io/docs/minio/linux/developers/go/API.html#PutObjectStreaming) +- [`StatObject`](https://min.io/docs/minio/linux/developers/go/API.html#StatObject) +- [`CopyObject`](https://min.io/docs/minio/linux/developers/go/API.html#CopyObject) +- [`RemoveObject`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveObject) +- [`RemoveObjects`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveObjects) +- [`RemoveIncompleteUpload`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveIncompleteUpload) +- [`SelectObjectContent`](https://min.io/docs/minio/linux/developers/go/API.html#SelectObjectContent) ### API Reference : Presigned Operations -* [`PresignedGetObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedGetObject) -* [`PresignedPutObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedPutObject) -* [`PresignedHeadObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedHeadObject) -* [`PresignedPostPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedPostPolicy) +- [`PresignedGetObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedGetObject) +- [`PresignedPutObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedPutObject) +- [`PresignedHeadObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedHeadObject) +- [`PresignedPostPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedPostPolicy) ### API Reference : Client custom settings -* [`SetAppInfo`](https://min.io/docs/minio/linux/developers/go/API.html#SetAppInfo) -* [`TraceOn`](https://min.io/docs/minio/linux/developers/go/API.html#TraceOn) -* [`TraceOff`](https://min.io/docs/minio/linux/developers/go/API.html#TraceOff) +- [`SetAppInfo`](https://min.io/docs/minio/linux/developers/go/API.html#SetAppInfo) +- [`TraceOn`](https://min.io/docs/minio/linux/developers/go/API.html#TraceOn) +- [`TraceOff`](https://min.io/docs/minio/linux/developers/go/API.html#TraceOff) -## Full Examples +Full Examples +------------- ### Full Examples : Bucket Operations -* [makebucket.go](https://github.com/minio/minio-go/blob/master/examples/s3/makebucket.go) -* [listbuckets.go](https://github.com/minio/minio-go/blob/master/examples/s3/listbuckets.go) -* [bucketexists.go](https://github.com/minio/minio-go/blob/master/examples/s3/bucketexists.go) -* [removebucket.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucket.go) -* [listobjects.go](https://github.com/minio/minio-go/blob/master/examples/s3/listobjects.go) -* [listobjectsV2.go](https://github.com/minio/minio-go/blob/master/examples/s3/listobjectsV2.go) -* [listincompleteuploads.go](https://github.com/minio/minio-go/blob/master/examples/s3/listincompleteuploads.go) +- [makebucket.go](https://github.com/minio/minio-go/blob/master/examples/s3/makebucket.go) +- [listbuckets.go](https://github.com/minio/minio-go/blob/master/examples/s3/listbuckets.go) +- [bucketexists.go](https://github.com/minio/minio-go/blob/master/examples/s3/bucketexists.go) +- [removebucket.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucket.go) +- [listobjects.go](https://github.com/minio/minio-go/blob/master/examples/s3/listobjects.go) +- [listobjectsV2.go](https://github.com/minio/minio-go/blob/master/examples/s3/listobjectsV2.go) +- [listincompleteuploads.go](https://github.com/minio/minio-go/blob/master/examples/s3/listincompleteuploads.go) ### Full Examples : Bucket policy Operations -* [setbucketpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketpolicy.go) -* [getbucketpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketpolicy.go) -* [listbucketpolicies.go](https://github.com/minio/minio-go/blob/master/examples/s3/listbucketpolicies.go) +- [setbucketpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketpolicy.go) +- [getbucketpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketpolicy.go) +- [listbucketpolicies.go](https://github.com/minio/minio-go/blob/master/examples/s3/listbucketpolicies.go) ### Full Examples : Bucket lifecycle Operations -* [setbucketlifecycle.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketlifecycle.go) -* [getbucketlifecycle.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketlifecycle.go) +- [setbucketlifecycle.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketlifecycle.go) +- [getbucketlifecycle.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketlifecycle.go) ### Full Examples : Bucket encryption Operations -* [setbucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketencryption.go) -* [getbucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketencryption.go) -* [removebucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucketencryption.go) +- [setbucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketencryption.go) +- [getbucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketencryption.go) +- [removebucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucketencryption.go) ### Full Examples : Bucket replication Operations -* [setbucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketreplication.go) -* [getbucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketreplication.go) -* [removebucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucketreplication.go) +- [setbucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketreplication.go) +- [getbucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketreplication.go) +- [removebucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucketreplication.go) ### Full Examples : Bucket notification Operations -* [setbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketnotification.go) -* [getbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketnotification.go) -* [removeallbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeallbucketnotification.go) -* [listenbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/minio/listenbucketnotification.go) (MinIO Extension) -* [listennotification.go](https://github.com/minio/minio-go/blob/master/examples/minio/listen-notification.go) (MinIO Extension) +- [setbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketnotification.go) +- [getbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketnotification.go) +- [removeallbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeallbucketnotification.go) +- [listenbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/minio/listenbucketnotification.go) (MinIO Extension) +- [listennotification.go](https://github.com/minio/minio-go/blob/master/examples/minio/listen-notification.go) (MinIO Extension) ### Full Examples : File Object Operations -* [fputobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/fputobject.go) -* [fgetobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/fgetobject.go) +- [fputobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/fputobject.go) +- [fgetobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/fgetobject.go) ### Full Examples : Object Operations -* [putobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/putobject.go) -* [getobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/getobject.go) -* [statobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/statobject.go) -* [copyobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/copyobject.go) -* [removeobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeobject.go) -* [removeincompleteupload.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeincompleteupload.go) -* [removeobjects.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeobjects.go) +- [putobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/putobject.go) +- [getobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/getobject.go) +- [statobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/statobject.go) +- [copyobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/copyobject.go) +- [removeobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeobject.go) +- [removeincompleteupload.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeincompleteupload.go) +- [removeobjects.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeobjects.go) ### Full Examples : Encrypted Object Operations -* [put-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/put-encrypted-object.go) -* [get-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/get-encrypted-object.go) -* [fput-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/fputencrypted-object.go) +- [put-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/put-encrypted-object.go) +- [get-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/get-encrypted-object.go) +- [fput-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/fputencrypted-object.go) ### Full Examples : Presigned Operations -* [presignedgetobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedgetobject.go) -* [presignedputobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedputobject.go) -* [presignedheadobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedheadobject.go) -* [presignedpostpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedpostpolicy.go) +- [presignedgetobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedgetobject.go) +- [presignedputobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedputobject.go) +- [presignedheadobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedheadobject.go) +- [presignedpostpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedpostpolicy.go) -## Explore Further +Explore Further +--------------- -* [Godoc Documentation](https://pkg.go.dev/github.com/minio/minio-go/v7) -* [Complete Documentation](https://min.io/docs/minio/kubernetes/upstream/index.html) -* [MinIO Go Client SDK API Reference](https://min.io/docs/minio/linux/developers/go/API.html) +- [Godoc Documentation](https://pkg.go.dev/github.com/minio/minio-go/v7) +- [Complete Documentation](https://min.io/docs/minio/kubernetes/upstream/index.html) +- [MinIO Go Client SDK API Reference](https://min.io/docs/minio/linux/developers/go/API.html) -## Contribute +Contribute +---------- [Contributors Guide](https://github.com/minio/minio-go/blob/master/CONTRIBUTING.md) -## License +License +------- This SDK is distributed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0), see [LICENSE](https://github.com/minio/minio-go/blob/master/LICENSE) and [NOTICE](https://github.com/minio/minio-go/blob/master/NOTICE) for more information. diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-cors.go b/vendor/github.com/minio/minio-go/v7/api-bucket-cors.go index 9d514947d..9967fe39e 100644 --- a/vendor/github.com/minio/minio-go/v7/api-bucket-cors.go +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-cors.go @@ -26,7 +26,15 @@ import ( "github.com/minio/minio-go/v7/pkg/s3utils" ) -// SetBucketCors sets the cors configuration for the bucket +// SetBucketCors sets the Cross-Origin Resource Sharing (CORS) configuration for the bucket. +// If corsConfig is nil, the existing CORS configuration will be removed. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - corsConfig: CORS configuration to apply (nil to remove existing configuration) +// +// Returns an error if the operation fails. func (c *Client) SetBucketCors(ctx context.Context, bucketName string, corsConfig *cors.Config) error { if err := s3utils.CheckValidBucketName(bucketName); err != nil { return err @@ -90,7 +98,14 @@ func (c *Client) removeBucketCors(ctx context.Context, bucketName string) error return nil } -// GetBucketCors returns the current cors +// GetBucketCors retrieves the Cross-Origin Resource Sharing (CORS) configuration from the bucket. +// If no CORS configuration exists, returns nil with no error. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the CORS configuration or an error if the operation fails. func (c *Client) GetBucketCors(ctx context.Context, bucketName string) (*cors.Config, error) { if err := s3utils.CheckValidBucketName(bucketName); err != nil { return nil, err diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go b/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go index 24f94e034..3ae9fe279 100644 --- a/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go @@ -28,6 +28,14 @@ import ( ) // SetBucketEncryption sets the default encryption configuration on an existing bucket. +// The encryption configuration specifies the default encryption behavior for objects uploaded to the bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - config: Server-side encryption configuration to apply +// +// Returns an error if the operation fails or if config is nil. func (c *Client) SetBucketEncryption(ctx context.Context, bucketName string, config *sse.Configuration) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -69,7 +77,15 @@ func (c *Client) SetBucketEncryption(ctx context.Context, bucketName string, con return nil } -// RemoveBucketEncryption removes the default encryption configuration on a bucket with a context to control cancellations and timeouts. +// RemoveBucketEncryption removes the default encryption configuration from a bucket. +// After removal, the bucket will no longer apply default encryption to new objects. +// It uses the provided context to control cancellations and timeouts. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns an error if the operation fails. func (c *Client) RemoveBucketEncryption(ctx context.Context, bucketName string) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -97,8 +113,14 @@ func (c *Client) RemoveBucketEncryption(ctx context.Context, bucketName string) return nil } -// GetBucketEncryption gets the default encryption configuration -// on an existing bucket with a context to control cancellations and timeouts. +// GetBucketEncryption retrieves the default encryption configuration from a bucket. +// It uses the provided context to control cancellations and timeouts. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the bucket's encryption configuration or an error if the operation fails. func (c *Client) GetBucketEncryption(ctx context.Context, bucketName string) (*sse.Configuration, error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go b/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go index 0d6011042..9e2a67769 100644 --- a/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go @@ -21,12 +21,12 @@ import ( "bufio" "bytes" "context" + "encoding/json" "encoding/xml" "net/http" "net/url" "time" - "github.com/minio/minio-go/v7/internal/json" "github.com/minio/minio-go/v7/pkg/notification" "github.com/minio/minio-go/v7/pkg/s3utils" ) diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go b/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go index 3a168c13e..0e561bdfa 100644 --- a/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go @@ -26,7 +26,16 @@ import ( "github.com/minio/minio-go/v7/pkg/s3utils" ) -// SetBucketPolicy sets the access permissions on an existing bucket. +// SetBucketPolicy sets the access permissions policy on an existing bucket. +// The policy should be a valid JSON string that conforms to the IAM policy format. +// If policy is an empty string, the existing bucket policy will be removed. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - policy: JSON policy string (empty string to remove existing policy) +// +// Returns an error if the operation fails. func (c *Client) SetBucketPolicy(ctx context.Context, bucketName, policy string) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -95,7 +104,14 @@ func (c *Client) removeBucketPolicy(ctx context.Context, bucketName string) erro return nil } -// GetBucketPolicy returns the current policy +// GetBucketPolicy retrieves the access permissions policy for the bucket. +// If no bucket policy exists, returns an empty string with no error. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the policy as a JSON string or an error if the operation fails. func (c *Client) GetBucketPolicy(ctx context.Context, bucketName string) (string, error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-qos.go b/vendor/github.com/minio/minio-go/v7/api-bucket-qos.go new file mode 100644 index 000000000..d1493a5b9 --- /dev/null +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-qos.go @@ -0,0 +1,212 @@ +/* + * MinIO Go Library for Amazon S3 Compatible Cloud Storage + * Copyright 2025 MinIO, Inc. + * 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. + */ + +package minio + +import ( + "context" + "encoding/json" + "io" + "net/http" + "net/url" + "strings" + + "github.com/minio/minio-go/v7/pkg/s3utils" + "gopkg.in/yaml.v3" +) + +// QOSConfigVersionCurrent is the current version of the QoS configuration. +const QOSConfigVersionCurrent = "v1" + +// QOSConfig represents the QoS configuration for a bucket. +type QOSConfig struct { + Version string `yaml:"version"` + Rules []QOSRule `yaml:"rules"` +} + +// QOSRule represents a single QoS rule. +type QOSRule struct { + ID string `yaml:"id"` + Label string `yaml:"label,omitempty"` + Priority int `yaml:"priority"` + ObjectPrefix string `yaml:"objectPrefix"` + API string `yaml:"api"` + Rate int64 `yaml:"rate"` + Burst int64 `yaml:"burst"` // not required for concurrency limit + Limit string `yaml:"limit"` // "concurrency" or "rps" +} + +// NewQOSConfig creates a new empty QoS configuration. +func NewQOSConfig() *QOSConfig { + return &QOSConfig{ + Version: "v1", + Rules: []QOSRule{}, + } +} + +// GetBucketQOS retrieves the Quality of Service (QoS) configuration for the bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// +// Returns the QoS configuration or an error if the operation fails. +func (c *Client) GetBucketQOS(ctx context.Context, bucket string) (*QOSConfig, error) { + var qosCfg QOSConfig + // Input validation. + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return nil, err + } + urlValues := make(url.Values) + urlValues.Set("qos", "") + // Execute GET on bucket to fetch qos. + resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{ + bucketName: bucket, + queryValues: urlValues, + contentSHA256Hex: emptySHA256Hex, + }) + defer closeResponse(resp) + if err != nil { + return nil, err + } + + if resp.StatusCode != http.StatusOK { + return nil, httpRespToErrorResponse(resp, bucket, "") + } + b, err := io.ReadAll(resp.Body) + if err != nil { + return nil, err + } + + if err = yaml.Unmarshal(b, &qosCfg); err != nil { + return nil, err + } + + return &qosCfg, nil +} + +// SetBucketQOS sets the Quality of Service (QoS) configuration for a bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - qosCfg: QoS configuration to apply +// +// Returns an error if the operation fails. +func (c *Client) SetBucketQOS(ctx context.Context, bucket string, qosCfg *QOSConfig) error { + // Input validation. + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return err + } + + data, err := yaml.Marshal(qosCfg) + if err != nil { + return err + } + // Get resources properly escaped and lined up before + // using them in http request. + urlValues := make(url.Values) + urlValues.Set("qos", "") + + reqMetadata := requestMetadata{ + bucketName: bucket, + queryValues: urlValues, + contentBody: strings.NewReader(string(data)), + contentLength: int64(len(data)), + } + + // Execute PUT to upload a new bucket QoS configuration. + resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata) + defer closeResponse(resp) + if err != nil { + return err + } + if resp != nil { + if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK { + return httpRespToErrorResponse(resp, bucket, "") + } + } + return nil +} + +// CounterMetric returns stats for a counter +type CounterMetric struct { + Last1m uint64 `json:"last1m"` + Last1hr uint64 `json:"last1hr"` + Total uint64 `json:"total"` +} + +// QOSMetric - metric for a qos rule per bucket +type QOSMetric struct { + APIName string `json:"apiName"` + Rule QOSRule `json:"rule"` + Totals CounterMetric `json:"totals"` + Throttled CounterMetric `json:"throttleCount"` + ExceededRateLimit CounterMetric `json:"exceededRateLimitCount"` + ClientDisconnCount CounterMetric `json:"clientDisconnectCount"` + ReqTimeoutCount CounterMetric `json:"reqTimeoutCount"` +} + +// QOSNodeStats represents stats for a bucket on a single node +type QOSNodeStats struct { + Stats []QOSMetric `json:"stats"` + NodeName string `json:"node"` +} + +// GetBucketQOSMetrics retrieves Quality of Service (QoS) metrics for a bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - nodeName: Name of the node (empty string for all nodes) +// +// Returns QoS metrics per node or an error if the operation fails. +func (c *Client) GetBucketQOSMetrics(ctx context.Context, bucketName, nodeName string) (qs []QOSNodeStats, err error) { + // Input validation. + if err := s3utils.CheckValidBucketName(bucketName); err != nil { + return qs, err + } + // Get resources properly escaped and lined up before + // using them in http request. + urlValues := make(url.Values) + urlValues.Set("qos-metrics", "") + if nodeName != "" { + urlValues.Set("node", nodeName) + } + // Execute GET on bucket to get qos metrics. + resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{ + bucketName: bucketName, + queryValues: urlValues, + }) + + defer closeResponse(resp) + if err != nil { + return qs, err + } + + if resp.StatusCode != http.StatusOK { + return qs, httpRespToErrorResponse(resp, bucketName, "") + } + respBytes, err := io.ReadAll(resp.Body) + if err != nil { + return qs, err + } + + if err := json.Unmarshal(respBytes, &qs); err != nil { + return qs, err + } + return qs, nil +} diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go b/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go index 8632bb85d..6dd7ae893 100644 --- a/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go @@ -20,6 +20,7 @@ package minio import ( "bytes" "context" + "encoding/json" "encoding/xml" "io" "net/http" @@ -27,17 +28,30 @@ import ( "time" "github.com/google/uuid" - "github.com/minio/minio-go/v7/internal/json" "github.com/minio/minio-go/v7/pkg/replication" "github.com/minio/minio-go/v7/pkg/s3utils" ) -// RemoveBucketReplication removes a replication config on an existing bucket. +// RemoveBucketReplication removes the replication configuration from an existing bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns an error if the operation fails. func (c *Client) RemoveBucketReplication(ctx context.Context, bucketName string) error { return c.removeBucketReplication(ctx, bucketName) } -// SetBucketReplication sets a replication config on an existing bucket. +// SetBucketReplication sets the replication configuration on an existing bucket. +// If the provided configuration is empty, this method removes the existing replication configuration. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - cfg: Replication configuration to apply +// +// Returns an error if the operation fails. func (c *Client) SetBucketReplication(ctx context.Context, bucketName string, cfg replication.Config) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -108,8 +122,14 @@ func (c *Client) removeBucketReplication(ctx context.Context, bucketName string) return nil } -// GetBucketReplication fetches bucket replication configuration.If config is not -// found, returns empty config with nil error. +// GetBucketReplication retrieves the bucket replication configuration. +// If no replication configuration is found, returns an empty config with nil error. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the replication configuration or an error if the operation fails. func (c *Client) GetBucketReplication(ctx context.Context, bucketName string) (cfg replication.Config, err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -155,7 +175,13 @@ func (c *Client) getBucketReplication(ctx context.Context, bucketName string) (c return cfg, nil } -// GetBucketReplicationMetrics fetches bucket replication status metrics +// GetBucketReplicationMetrics retrieves bucket replication status metrics. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the replication metrics or an error if the operation fails. func (c *Client) GetBucketReplicationMetrics(ctx context.Context, bucketName string) (s replication.Metrics, err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -200,8 +226,15 @@ func mustGetUUID() string { return u.String() } -// ResetBucketReplication kicks off replication of previously replicated objects if ExistingObjectReplication -// is enabled in the replication config +// ResetBucketReplication initiates replication of previously replicated objects. +// This requires ExistingObjectReplication to be enabled in the replication configuration. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - olderThan: Only replicate objects older than this duration (0 for all objects) +// +// Returns a reset ID that can be used to track the operation, or an error if the operation fails. func (c *Client) ResetBucketReplication(ctx context.Context, bucketName string, olderThan time.Duration) (rID string, err error) { rID = mustGetUUID() _, err = c.resetBucketReplicationOnTarget(ctx, bucketName, olderThan, "", rID) @@ -211,8 +244,16 @@ func (c *Client) ResetBucketReplication(ctx context.Context, bucketName string, return rID, nil } -// ResetBucketReplicationOnTarget kicks off replication of previously replicated objects if -// ExistingObjectReplication is enabled in the replication config +// ResetBucketReplicationOnTarget initiates replication of previously replicated objects to a specific target. +// This requires ExistingObjectReplication to be enabled in the replication configuration. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - olderThan: Only replicate objects older than this duration (0 for all objects) +// - tgtArn: ARN of the target to reset replication for +// +// Returns resync target information or an error if the operation fails. func (c *Client) ResetBucketReplicationOnTarget(ctx context.Context, bucketName string, olderThan time.Duration, tgtArn string) (replication.ResyncTargetsInfo, error) { return c.resetBucketReplicationOnTarget(ctx, bucketName, olderThan, tgtArn, mustGetUUID()) } @@ -222,7 +263,7 @@ func (c *Client) ResetBucketReplicationOnTarget(ctx context.Context, bucketName func (c *Client) resetBucketReplicationOnTarget(ctx context.Context, bucketName string, olderThan time.Duration, tgtArn, resetID string) (rinfo replication.ResyncTargetsInfo, err error) { // Input validation. if err = s3utils.CheckValidBucketName(bucketName); err != nil { - return + return rinfo, err } // Get resources properly escaped and lined up before // using them in http request. @@ -256,7 +297,14 @@ func (c *Client) resetBucketReplicationOnTarget(ctx context.Context, bucketName return rinfo, nil } -// GetBucketReplicationResyncStatus gets the status of replication resync +// GetBucketReplicationResyncStatus retrieves the status of a replication resync operation. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - arn: ARN of the replication target (empty string for all targets) +// +// Returns resync status information or an error if the operation fails. func (c *Client) GetBucketReplicationResyncStatus(ctx context.Context, bucketName, arn string) (rinfo replication.ResyncTargetsInfo, err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -290,11 +338,18 @@ func (c *Client) GetBucketReplicationResyncStatus(ctx context.Context, bucketNam return rinfo, nil } -// CancelBucketReplicationResync cancels in progress replication resync +// CancelBucketReplicationResync cancels an in-progress replication resync operation. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - tgtArn: ARN of the replication target (empty string for all targets) +// +// Returns the ID of the canceled resync operation or an error if the operation fails. func (c *Client) CancelBucketReplicationResync(ctx context.Context, bucketName string, tgtArn string) (id string, err error) { // Input validation. if err = s3utils.CheckValidBucketName(bucketName); err != nil { - return + return id, err } // Get resources properly escaped and lined up before // using them in http request. @@ -326,7 +381,13 @@ func (c *Client) CancelBucketReplicationResync(ctx context.Context, bucketName s return id, nil } -// GetBucketReplicationMetricsV2 fetches bucket replication status metrics +// GetBucketReplicationMetricsV2 retrieves bucket replication status metrics using the V2 API. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the V2 replication metrics or an error if the operation fails. func (c *Client) GetBucketReplicationMetricsV2(ctx context.Context, bucketName string) (s replication.MetricsV2, err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -362,7 +423,13 @@ func (c *Client) GetBucketReplicationMetricsV2(ctx context.Context, bucketName s return s, nil } -// CheckBucketReplication validates if replication is set up properly for a bucket +// CheckBucketReplication validates whether replication is properly configured for a bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns nil if replication is valid, or an error describing the validation failure. func (c *Client) CheckBucketReplication(ctx context.Context, bucketName string) (err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go b/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go index 86d74298a..921f90f99 100644 --- a/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go +++ b/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go @@ -29,8 +29,14 @@ import ( "github.com/minio/minio-go/v7/pkg/tags" ) -// GetBucketTagging fetch tagging configuration for a bucket with a -// context to control cancellations and timeouts. +// GetBucketTagging fetches the tagging configuration for a bucket. +// It uses the provided context to control cancellations and timeouts. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns the bucket's tags or an error if the operation fails. func (c *Client) GetBucketTagging(ctx context.Context, bucketName string) (*tags.Tags, error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -61,8 +67,15 @@ func (c *Client) GetBucketTagging(ctx context.Context, bucketName string) (*tags return tags.ParseBucketXML(resp.Body) } -// SetBucketTagging sets tagging configuration for a bucket -// with a context to control cancellations and timeouts. +// SetBucketTagging sets the tagging configuration for a bucket. +// It uses the provided context to control cancellations and timeouts. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - tags: Tag set to apply to the bucket +// +// Returns an error if the operation fails or if tags is nil. func (c *Client) SetBucketTagging(ctx context.Context, bucketName string, tags *tags.Tags) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -104,8 +117,14 @@ func (c *Client) SetBucketTagging(ctx context.Context, bucketName string, tags * return nil } -// RemoveBucketTagging removes tagging configuration for a -// bucket with a context to control cancellations and timeouts. +// RemoveBucketTagging removes the tagging configuration from a bucket. +// It uses the provided context to control cancellations and timeouts. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// +// Returns an error if the operation fails. func (c *Client) RemoveBucketTagging(ctx context.Context, bucketName string) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { diff --git a/vendor/github.com/minio/minio-go/v7/api-compose-object.go b/vendor/github.com/minio/minio-go/v7/api-compose-object.go index 154af7121..232bd2c01 100644 --- a/vendor/github.com/minio/minio-go/v7/api-compose-object.go +++ b/vendor/github.com/minio/minio-go/v7/api-compose-object.go @@ -42,13 +42,15 @@ type CopyDestOptions struct { // provided key. If it is nil, no encryption is performed. Encryption encrypt.ServerSide + ChecksumType ChecksumType + // `userMeta` is the user-metadata key-value pairs to be set on the // destination. The keys are automatically prefixed with `x-amz-meta-` // if needed. If nil is passed, and if only a single source (of any // size) is provided in the ComposeObject call, then metadata from the // source is copied to the destination. // if no user-metadata is provided, it is copied from source - // (when there is only once source object in the compose + // (when there is only one source object in the compose // request) UserMetadata map[string]string // UserMetadata is only set to destination if ReplaceMetadata is true @@ -140,6 +142,9 @@ func (opts CopyDestOptions) Marshal(header http.Header) { if !opts.Expires.IsZero() { header.Set("Expires", opts.Expires.UTC().Format(http.TimeFormat)) } + if opts.ChecksumType.IsSet() { + header.Set(amzChecksumAlgo, opts.ChecksumType.String()) + } if opts.ReplaceMetadata { header.Set("x-amz-metadata-directive", replaceDirective) @@ -345,7 +350,7 @@ func (c *Client) copyObjectPartDo(ctx context.Context, srcBucket, srcObject, des }) defer closeResponse(resp) if err != nil { - return + return p, err } // Check if we got an error response. @@ -580,7 +585,7 @@ func partsRequired(size int64) int64 { // it is not the last part. func calculateEvenSplits(size int64, src CopySrcOptions) (startIndex, endIndex []int64) { if size == 0 { - return + return startIndex, endIndex } reqParts := partsRequired(size) @@ -617,5 +622,5 @@ func calculateEvenSplits(size int64, src CopySrcOptions) (startIndex, endIndex [ startIndex[j], endIndex[j] = cStart, cEnd } - return + return startIndex, endIndex } diff --git a/vendor/github.com/minio/minio-go/v7/api-error-response.go b/vendor/github.com/minio/minio-go/v7/api-error-response.go index e85aa322c..e5f88d98e 100644 --- a/vendor/github.com/minio/minio-go/v7/api-error-response.go +++ b/vendor/github.com/minio/minio-go/v7/api-error-response.go @@ -20,6 +20,7 @@ package minio import ( "bytes" "encoding/xml" + "errors" "fmt" "io" "net/http" @@ -128,9 +129,18 @@ func httpRespToErrorResponse(resp *http.Response, bucketName, objectName string) Server: resp.Header.Get("Server"), } + _, success := successStatus[resp.StatusCode] + errBody, err := xmlDecodeAndBody(resp.Body, &errResp) // Xml decoding failed with no body, fall back to HTTP headers. if err != nil { + var unmarshalErr xml.UnmarshalError + if success && errors.As(err, &unmarshalErr) { + // This is a successful message so not an error response + // return nil, + return nil + } + switch resp.StatusCode { case http.StatusNotFound: if objectName == "" { diff --git a/vendor/github.com/minio/minio-go/v7/api-get-object-attributes.go b/vendor/github.com/minio/minio-go/v7/api-get-object-attributes.go index e1155c372..d2e8cabde 100644 --- a/vendor/github.com/minio/minio-go/v7/api-get-object-attributes.go +++ b/vendor/github.com/minio/minio-go/v7/api-get-object-attributes.go @@ -127,7 +127,7 @@ func (o *ObjectAttributes) parseResponse(resp *http.Response) (err error) { } o.ObjectAttributesResponse = *response - return + return err } // GetObjectAttributes API combines HeadObject and ListParts. diff --git a/vendor/github.com/minio/minio-go/v7/api-get-object-file.go b/vendor/github.com/minio/minio-go/v7/api-get-object-file.go index 567a42e45..6ef9c9330 100644 --- a/vendor/github.com/minio/minio-go/v7/api-get-object-file.go +++ b/vendor/github.com/minio/minio-go/v7/api-get-object-file.go @@ -69,7 +69,7 @@ func (c *Client) FGetObject(ctx context.Context, bucketName, objectName, filePat } // Write to a temporary file "fileName.part.minio" before saving. - filePartPath := filePath + sum256Hex([]byte(objectStat.ETag)) + ".part.minio" + filePartPath := filepath.Join(filepath.Dir(filePath), sum256Hex([]byte(filepath.Base(filePath)+objectStat.ETag))+".part.minio") // If exists, open in append mode. If not create it as a part file. filePart, err := os.OpenFile(filePartPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600) diff --git a/vendor/github.com/minio/minio-go/v7/api-inventory-ext.go b/vendor/github.com/minio/minio-go/v7/api-inventory-ext.go new file mode 100644 index 000000000..498300785 --- /dev/null +++ b/vendor/github.com/minio/minio-go/v7/api-inventory-ext.go @@ -0,0 +1,332 @@ +/* + * MinIO Go Library for Amazon S3 Compatible Cloud Storage + * Copyright 2015-2025 MinIO, Inc. + * + * 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. + */ + +package minio + +import ( + "context" + "encoding/json" + "io" + "iter" + "net/http" + "net/url" + "strings" + "time" + + "github.com/minio/minio-go/v7/pkg/s3utils" +) + +// This file contains the inventory API extension for MinIO server. It is not +// compatible with AWS S3. + +func makeInventoryReqMetadata(bucket string, urlParams ...string) requestMetadata { + urlValues := make(url.Values) + urlValues.Set("minio-inventory", "") + + // If an odd number of parameters is given, we skip the last pair to avoid + // an out of bounds access. + for i := 0; i+1 < len(urlParams); i += 2 { + urlValues.Set(urlParams[i], urlParams[i+1]) + } + + return requestMetadata{ + bucketName: bucket, + queryValues: urlValues, + } +} + +// GenerateInventoryConfigYAML generates a YAML template for an inventory configuration. +// This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - id: Unique identifier for the inventory configuration +// +// Returns a YAML template string that can be customized and used with PutBucketInventoryConfiguration. +func (c *Client) GenerateInventoryConfigYAML(ctx context.Context, bucket, id string) (string, error) { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return "", err + } + if id == "" { + return "", errInvalidArgument("inventory ID cannot be empty") + } + reqMeta := makeInventoryReqMetadata(bucket, "generate", "", "id", id) + resp, err := c.executeMethod(ctx, http.MethodGet, reqMeta) + defer closeResponse(resp) + if err != nil { + return "", err + } + if resp.StatusCode != http.StatusOK { + return "", httpRespToErrorResponse(resp, bucket, "") + } + buf := new(strings.Builder) + _, err = io.Copy(buf, resp.Body) + return buf.String(), err +} + +// inventoryPutConfigOpts is a placeholder for future options that may be added. +type inventoryPutConfigOpts struct{} + +// InventoryPutConfigOption is to allow for functional options for +// PutBucketInventoryConfiguration. It may be used in the future to customize +// the PutBucketInventoryConfiguration request, but currently does not do +// anything. +type InventoryPutConfigOption func(*inventoryPutConfigOpts) + +// PutBucketInventoryConfiguration creates or updates an inventory configuration for a bucket. +// This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - id: Unique identifier for the inventory configuration +// - yamlDef: YAML definition of the inventory configuration +// +// Returns an error if the operation fails, or if bucket name, id, or yamlDef is empty. +func (c *Client) PutBucketInventoryConfiguration(ctx context.Context, bucket string, id string, yamlDef string, _ ...InventoryPutConfigOption) error { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return err + } + if id == "" { + return errInvalidArgument("inventory ID cannot be empty") + } + if yamlDef == "" { + return errInvalidArgument("YAML definition cannot be empty") + } + reqMeta := makeInventoryReqMetadata(bucket, "id", id) + reqMeta.contentBody = strings.NewReader(yamlDef) + reqMeta.contentLength = int64(len(yamlDef)) + reqMeta.contentMD5Base64 = sumMD5Base64([]byte(yamlDef)) + + resp, err := c.executeMethod(ctx, http.MethodPut, reqMeta) + defer closeResponse(resp) + if err != nil { + return err + } + if resp.StatusCode != http.StatusOK { + return httpRespToErrorResponse(resp, bucket, "") + } + return nil +} + +// GetBucketInventoryConfiguration retrieves the inventory configuration for a bucket. +// This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - id: Unique identifier for the inventory configuration +// +// Returns the inventory configuration or an error if the operation fails or if the configuration doesn't exist. +func (c *Client) GetBucketInventoryConfiguration(ctx context.Context, bucket, id string) (*InventoryConfiguration, error) { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return nil, err + } + if id == "" { + return nil, errInvalidArgument("inventory ID cannot be empty") + } + reqMeta := makeInventoryReqMetadata(bucket, "id", id) + resp, err := c.executeMethod(ctx, http.MethodGet, reqMeta) + defer closeResponse(resp) + if err != nil { + return nil, err + } + if resp.StatusCode != http.StatusOK { + return nil, httpRespToErrorResponse(resp, bucket, "") + } + decoder := json.NewDecoder(resp.Body) + var ic InventoryConfiguration + err = decoder.Decode(&ic) + if err != nil { + return nil, err + } + return &ic, nil +} + +// DeleteBucketInventoryConfiguration deletes an inventory configuration from a bucket. +// This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - id: Unique identifier for the inventory configuration to delete +// +// Returns an error if the operation fails or if the configuration doesn't exist. +func (c *Client) DeleteBucketInventoryConfiguration(ctx context.Context, bucket, id string) error { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return err + } + if id == "" { + return errInvalidArgument("inventory ID cannot be empty") + } + reqMeta := makeInventoryReqMetadata(bucket, "id", id) + resp, err := c.executeMethod(ctx, http.MethodDelete, reqMeta) + defer closeResponse(resp) + if err != nil { + return err + } + if resp.StatusCode != http.StatusOK { + return httpRespToErrorResponse(resp, bucket, "") + } + return nil +} + +// InventoryConfiguration represents the inventory configuration +type InventoryConfiguration struct { + Bucket string `json:"bucket"` + ID string `json:"id"` + User string `json:"user"` + YamlDef string `json:"yamlDef,omitempty"` +} + +// InventoryListResult represents the result of listing inventory +// configurations. +type InventoryListResult struct { + Items []InventoryConfiguration `json:"items"` + NextContinuationToken string `json:"nextContinuationToken,omitempty"` +} + +// ListBucketInventoryConfigurations lists up to 100 inventory configurations for a bucket. +// This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - continuationToken: Token for pagination (empty string for first request) +// +// Returns a list result with configurations and a continuation token for the next page, or an error. +func (c *Client) ListBucketInventoryConfigurations(ctx context.Context, bucket, continuationToken string) (lr *InventoryListResult, err error) { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return nil, err + } + reqMeta := makeInventoryReqMetadata(bucket, "continuation-token", continuationToken) + resp, err := c.executeMethod(ctx, http.MethodGet, reqMeta) + defer closeResponse(resp) + if err != nil { + return nil, err + } + if resp.StatusCode != http.StatusOK { + return nil, httpRespToErrorResponse(resp, bucket, "") + } + + decoder := json.NewDecoder(resp.Body) + err = decoder.Decode(&lr) + if err != nil { + return nil, err + } + return lr, nil +} + +// ListBucketInventoryConfigurationsIterator returns an iterator that lists all inventory configurations +// for a bucket. This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// +// Returns an iterator that yields InventoryConfiguration values and errors. The iterator automatically +// handles pagination and fetches all configurations. +func (c *Client) ListBucketInventoryConfigurationsIterator(ctx context.Context, bucket string) iter.Seq2[InventoryConfiguration, error] { + return func(yield func(InventoryConfiguration, error) bool) { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + yield(InventoryConfiguration{}, err) + return + } + var continuationToken string + for { + listResult, err := c.ListBucketInventoryConfigurations(ctx, bucket, continuationToken) + if err != nil { + yield(InventoryConfiguration{}, err) + return + } + + for _, item := range listResult.Items { + if !yield(item, nil) { + return + } + } + + if listResult.NextContinuationToken == "" { + return + } + continuationToken = listResult.NextContinuationToken + } + } +} + +// InventoryJobStatus represents the status of an inventory job. +type InventoryJobStatus struct { + Bucket string `json:"bucket"` + ID string `json:"id"` + User string `json:"user"` + AccessKey string `json:"accessKey"` + Schedule string `json:"schedule"` + State string `json:"state"` + NextScheduledTime time.Time `json:"nextScheduledTime,omitempty"` + StartTime time.Time `json:"startTime,omitempty"` + EndTime time.Time `json:"endTime,omitempty"` + LastUpdate time.Time `json:"lastUpdate,omitempty"` + Scanned string `json:"scanned,omitempty"` + Matched string `json:"matched,omitempty"` + ScannedCount uint64 `json:"scannedCount,omitempty"` + MatchedCount uint64 `json:"matchedCount,omitempty"` + RecordsWritten uint64 `json:"recordsWritten,omitempty"` + OutputFilesCount uint64 `json:"outputFilesCount,omitempty"` + ExecutionTime string `json:"executionTime,omitempty"` + NumStarts uint64 `json:"numStarts,omitempty"` + NumErrors uint64 `json:"numErrors,omitempty"` + NumLockLosses uint64 `json:"numLockLosses,omitempty"` + ManifestPath string `json:"manifestPath,omitempty"` + RetryAttempts uint64 `json:"retryAttempts,omitempty"` + LastFailTime time.Time `json:"lastFailTime,omitempty"` + LastFailErrors []string `json:"lastFailErrors,omitempty"` +} + +// GetBucketInventoryJobStatus retrieves the status of an inventory job for a bucket. +// This is a MinIO-specific API and is not compatible with AWS S3. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucket: Name of the bucket +// - id: Unique identifier for the inventory job +// +// Returns the inventory job status including execution state, progress, and error information, or an error if the operation fails. +func (c *Client) GetBucketInventoryJobStatus(ctx context.Context, bucket, id string) (*InventoryJobStatus, error) { + if err := s3utils.CheckValidBucketName(bucket); err != nil { + return nil, err + } + if id == "" { + return nil, errInvalidArgument("inventory ID cannot be empty") + } + reqMeta := makeInventoryReqMetadata(bucket, "id", id, "status", "") + resp, err := c.executeMethod(ctx, http.MethodGet, reqMeta) + defer closeResponse(resp) + if err != nil { + return nil, err + } + if resp.StatusCode != http.StatusOK { + return nil, httpRespToErrorResponse(resp, bucket, "") + } + decoder := json.NewDecoder(resp.Body) + var jStatus InventoryJobStatus + err = decoder.Decode(&jStatus) + if err != nil { + return nil, err + } + return &jStatus, nil +} diff --git a/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go b/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go index 0c027d550..5ad9a4943 100644 --- a/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go +++ b/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go @@ -80,7 +80,16 @@ func newObjectLegalHold(status *LegalHoldStatus) (*objectLegalHold, error) { return legalHold, nil } -// PutObjectLegalHold : sets object legal hold for a given object and versionID. +// PutObjectLegalHold sets the legal hold status for an object and specific version. +// Legal hold prevents an object version from being overwritten or deleted, regardless of retention settings. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - opts: Options including Status (LegalHoldEnabled or LegalHoldDisabled) and optional VersionID +// +// Returns an error if the operation fails or if the status is invalid. func (c *Client) PutObjectLegalHold(ctx context.Context, bucketName, objectName string, opts PutObjectLegalHoldOptions) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -134,7 +143,15 @@ func (c *Client) PutObjectLegalHold(ctx context.Context, bucketName, objectName return nil } -// GetObjectLegalHold gets legal-hold status of given object. +// GetObjectLegalHold retrieves the legal hold status for an object and specific version. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - opts: Options including optional VersionID to target a specific version +// +// Returns the legal hold status (LegalHoldEnabled or LegalHoldDisabled) or an error if the operation fails. func (c *Client) GetObjectLegalHold(ctx context.Context, bucketName, objectName string, opts GetObjectLegalHoldOptions) (status *LegalHoldStatus, err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { diff --git a/vendor/github.com/minio/minio-go/v7/api-object-retention.go b/vendor/github.com/minio/minio-go/v7/api-object-retention.go index b29cb1f8d..2efb5d89a 100644 --- a/vendor/github.com/minio/minio-go/v7/api-object-retention.go +++ b/vendor/github.com/minio/minio-go/v7/api-object-retention.go @@ -62,7 +62,16 @@ type PutObjectRetentionOptions struct { VersionID string } -// PutObjectRetention sets object retention for a given object and versionID. +// PutObjectRetention sets the retention configuration for an object and specific version. +// Object retention prevents an object version from being deleted or overwritten for a specified period. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - opts: Options including Mode (GOVERNANCE or COMPLIANCE), RetainUntilDate, optional VersionID, and GovernanceBypass +// +// Returns an error if the operation fails or if the retention settings are invalid. func (c *Client) PutObjectRetention(ctx context.Context, bucketName, objectName string, opts PutObjectRetentionOptions) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -125,7 +134,15 @@ func (c *Client) PutObjectRetention(ctx context.Context, bucketName, objectName return nil } -// GetObjectRetention gets retention of given object. +// GetObjectRetention retrieves the retention configuration for an object and specific version. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - versionID: Optional version ID to target a specific version (empty string for current version) +// +// Returns the retention mode (GOVERNANCE or COMPLIANCE), retain-until date, and any error. func (c *Client) GetObjectRetention(ctx context.Context, bucketName, objectName, versionID string) (mode *RetentionMode, retainUntilDate *time.Time, err error) { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { diff --git a/vendor/github.com/minio/minio-go/v7/api-object-tagging.go b/vendor/github.com/minio/minio-go/v7/api-object-tagging.go index 6623e262a..66d131106 100644 --- a/vendor/github.com/minio/minio-go/v7/api-object-tagging.go +++ b/vendor/github.com/minio/minio-go/v7/api-object-tagging.go @@ -40,8 +40,17 @@ type AdvancedObjectTaggingOptions struct { ReplicationProxyRequest string } -// PutObjectTagging replaces or creates object tag(s) and can target -// a specific object version in a versioned bucket. +// PutObjectTagging replaces or creates object tag(s) and can target a specific object version +// in a versioned bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - otags: Tags to apply to the object +// - opts: Options including VersionID to target a specific version +// +// Returns an error if the operation fails. func (c *Client) PutObjectTagging(ctx context.Context, bucketName, objectName string, otags *tags.Tags, opts PutObjectTaggingOptions) error { // Input validation. if err := s3utils.CheckValidBucketName(bucketName); err != nil { @@ -96,8 +105,16 @@ type GetObjectTaggingOptions struct { Internal AdvancedObjectTaggingOptions } -// GetObjectTagging fetches object tag(s) with options to target -// a specific object version in a versioned bucket. +// GetObjectTagging retrieves object tag(s) with options to target a specific object version +// in a versioned bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - opts: Options including VersionID to target a specific version +// +// Returns the object's tags or an error if the operation fails. func (c *Client) GetObjectTagging(ctx context.Context, bucketName, objectName string, opts GetObjectTaggingOptions) (*tags.Tags, error) { // Get resources properly escaped and lined up before // using them in http request. @@ -139,8 +156,16 @@ type RemoveObjectTaggingOptions struct { Internal AdvancedObjectTaggingOptions } -// RemoveObjectTagging removes object tag(s) with options to control a specific object -// version in a versioned bucket +// RemoveObjectTagging removes object tag(s) with options to target a specific object version +// in a versioned bucket. +// +// Parameters: +// - ctx: Context for request cancellation and timeout +// - bucketName: Name of the bucket +// - objectName: Name of the object +// - opts: Options including VersionID to target a specific version +// +// Returns an error if the operation fails. func (c *Client) RemoveObjectTagging(ctx context.Context, bucketName, objectName string, opts RemoveObjectTaggingOptions) error { // Get resources properly escaped and lined up before // using them in http request. diff --git a/vendor/github.com/minio/minio-go/v7/api-prompt-object.go b/vendor/github.com/minio/minio-go/v7/api-prompt-object.go index 26c41d34a..55c038ae0 100644 --- a/vendor/github.com/minio/minio-go/v7/api-prompt-object.go +++ b/vendor/github.com/minio/minio-go/v7/api-prompt-object.go @@ -20,10 +20,10 @@ package minio import ( "bytes" "context" + "encoding/json" "io" "net/http" - "github.com/minio/minio-go/v7/internal/json" "github.com/minio/minio-go/v7/pkg/s3utils" ) diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-common.go b/vendor/github.com/minio/minio-go/v7/api-put-object-common.go index 9ccb97cbb..52f69563c 100644 --- a/vendor/github.com/minio/minio-go/v7/api-put-object-common.go +++ b/vendor/github.com/minio/minio-go/v7/api-put-object-common.go @@ -31,7 +31,7 @@ const nullVersionID = "null" // Verify if reader is *minio.Object func isObject(reader io.Reader) (ok bool) { _, ok = reader.(*Object) - return + return ok } // Verify if reader is a generic ReaderAt @@ -56,7 +56,7 @@ func isReadAt(reader io.Reader) (ok bool) { } else { _, ok = reader.(io.ReaderAt) } - return + return ok } // OptimalPartInfo - calculate the optimal part info for a given @@ -79,31 +79,31 @@ func OptimalPartInfo(objectSize int64, configuredPartSize uint64) (totalPartsCou // object size is larger than supported maximum. if objectSize > maxMultipartPutObjectSize { err = errEntityTooLarge(objectSize, maxMultipartPutObjectSize, "", "") - return + return totalPartsCount, partSize, lastPartSize, err } var partSizeFlt float64 if configuredPartSize > 0 { if int64(configuredPartSize) > objectSize { err = errEntityTooLarge(int64(configuredPartSize), objectSize, "", "") - return + return totalPartsCount, partSize, lastPartSize, err } if !unknownSize { if objectSize > (int64(configuredPartSize) * maxPartsCount) { err = errInvalidArgument("Part size * max_parts(10000) is lesser than input objectSize.") - return + return totalPartsCount, partSize, lastPartSize, err } } if configuredPartSize < absMinPartSize { err = errInvalidArgument("Input part size is smaller than allowed minimum of 5MiB.") - return + return totalPartsCount, partSize, lastPartSize, err } if configuredPartSize > maxPartSize { err = errInvalidArgument("Input part size is bigger than allowed maximum of 5GiB.") - return + return totalPartsCount, partSize, lastPartSize, err } partSizeFlt = float64(configuredPartSize) diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go b/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go index a6b5149f0..3023b949c 100644 --- a/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go +++ b/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go @@ -19,6 +19,7 @@ package minio import ( "context" + "encoding/json" "errors" "io" "mime/multipart" @@ -27,7 +28,6 @@ import ( "strings" "time" - "github.com/minio/minio-go/v7/internal/json" "github.com/minio/minio-go/v7/pkg/encrypt" ) diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go b/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go index db5314d5f..79d0c1dc1 100644 --- a/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go +++ b/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go @@ -210,9 +210,13 @@ func (c *Client) putObjectMultipartStreamFromReadAt(ctx context.Context, bucketN } objPart, err := c.uploadPart(ctx, p) if err != nil { - uploadedPartsCh <- uploadedPartRes{ + select { + case <-ctx.Done(): + case uploadedPartsCh <- uploadedPartRes{ Error: err, + }: } + // Exit the goroutine. return } @@ -221,10 +225,13 @@ func (c *Client) putObjectMultipartStreamFromReadAt(ctx context.Context, bucketN uploadReq.Part = objPart // Send successful part info through the channel. - uploadedPartsCh <- uploadedPartRes{ + select { + case <-ctx.Done(): + case uploadedPartsCh <- uploadedPartRes{ Size: objPart.Size, PartNum: uploadReq.PartNum, Part: uploadReq.Part, + }: } } }(partSize) diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object.go b/vendor/github.com/minio/minio-go/v7/api-put-object.go index 877cecb84..80f3d61f3 100644 --- a/vendor/github.com/minio/minio-go/v7/api-put-object.go +++ b/vendor/github.com/minio/minio-go/v7/api-put-object.go @@ -150,7 +150,7 @@ func (opts PutObjectOptions) getNumThreads() (numThreads int) { } else { numThreads = totalWorkers } - return + return numThreads } // Header - constructs the headers from metadata entered by user in @@ -249,7 +249,7 @@ func (opts PutObjectOptions) Header() (header http.Header) { header[k] = v } - return + return header } // validate() checks if the UserMetadata map has standard headers or and raises an error if so. diff --git a/vendor/github.com/minio/minio-go/v7/api-remove.go b/vendor/github.com/minio/minio-go/v7/api-remove.go index 2a38e014a..9794ffb2b 100644 --- a/vendor/github.com/minio/minio-go/v7/api-remove.go +++ b/vendor/github.com/minio/minio-go/v7/api-remove.go @@ -617,12 +617,11 @@ func (c *Client) removeObjects(ctx context.Context, bucketName string, objectsCh customHeader: headers, expect200OKWithError: true, }) - if resp != nil { - if resp.StatusCode != http.StatusOK { - e := httpRespToErrorResponse(resp, bucketName, "") - resultCh <- RemoveObjectResult{ObjectName: "", Err: e} - } + + if resp != nil && resp.StatusCode != http.StatusOK { + err = httpRespToErrorResponse(resp, bucketName, "") } + if err != nil { for _, b := range batch { resultCh <- RemoveObjectResult{ diff --git a/vendor/github.com/minio/minio-go/v7/api.go b/vendor/github.com/minio/minio-go/v7/api.go index 53ef6b85a..5352d793b 100644 --- a/vendor/github.com/minio/minio-go/v7/api.go +++ b/vendor/github.com/minio/minio-go/v7/api.go @@ -21,7 +21,6 @@ import ( "bytes" "context" "encoding/base64" - "encoding/xml" "errors" "fmt" "io" @@ -43,7 +42,6 @@ import ( md5simd "github.com/minio/md5-simd" "github.com/minio/minio-go/v7/pkg/credentials" "github.com/minio/minio-go/v7/pkg/kvcache" - "github.com/minio/minio-go/v7/pkg/peeker" "github.com/minio/minio-go/v7/pkg/s3utils" "github.com/minio/minio-go/v7/pkg/signer" "github.com/minio/minio-go/v7/pkg/singleflight" @@ -162,7 +160,7 @@ type Options struct { // Global constants. const ( libraryName = "minio-go" - libraryVersion = "v7.0.95" + libraryVersion = "v7.0.96" ) // User Agent should always following the below style. @@ -204,7 +202,9 @@ func New(endpoint string, opts *Options) (*Client, error) { return clnt, nil } -// EndpointURL returns the URL of the S3 endpoint. +// EndpointURL returns the URL of the S3-compatible endpoint that this client connects to. +// +// Returns a copy of the endpoint URL to prevent modification of internal state. func (c *Client) EndpointURL() *url.URL { endpoint := *c.endpointURL // copy to prevent callers from modifying internal state return &endpoint @@ -221,7 +221,7 @@ func (r *lockedRandSource) Int63() (n int64) { r.lk.Lock() n = r.src.Int63() r.lk.Unlock() - return + return n } // Seed uses the provided seed value to initialize the generator to a @@ -325,7 +325,14 @@ func privateNew(endpoint string, opts *Options) (*Client, error) { return clnt, nil } -// SetAppInfo - add application details to user agent. +// SetAppInfo adds custom application name and version to the User-Agent header for all requests. +// This helps identify your application in server logs and metrics. +// +// Parameters: +// - appName: Name of the application +// - appVersion: Version of the application +// +// Both parameters must be non-empty for the custom User-Agent to be set. func (c *Client) SetAppInfo(appName, appVersion string) { // if app name and version not set, we do not set a new user agent. if appName != "" && appVersion != "" { @@ -334,7 +341,11 @@ func (c *Client) SetAppInfo(appName, appVersion string) { } } -// TraceOn - enable HTTP tracing. +// TraceOn enables HTTP request and response tracing for debugging purposes. +// All HTTP traffic will be written to the provided output stream. +// +// Parameters: +// - outputStream: Writer where trace output will be written (defaults to os.Stdout if nil) func (c *Client) TraceOn(outputStream io.Writer) { // if outputStream is nil then default to os.Stdout. if outputStream == nil { @@ -347,19 +358,23 @@ func (c *Client) TraceOn(outputStream io.Writer) { c.isTraceEnabled = true } -// TraceErrorsOnlyOn - same as TraceOn, but only errors will be traced. +// TraceErrorsOnlyOn enables HTTP tracing but only for requests that result in errors. +// This is useful for debugging without the overhead of tracing all requests. +// +// Parameters: +// - outputStream: Writer where trace output will be written (defaults to os.Stdout if nil) func (c *Client) TraceErrorsOnlyOn(outputStream io.Writer) { c.TraceOn(outputStream) c.traceErrorsOnly = true } -// TraceErrorsOnlyOff - Turns off the errors only tracing and everything will be traced after this call. -// If all tracing needs to be turned off, call TraceOff(). +// TraceErrorsOnlyOff disables errors-only mode and traces all requests. +// To disable all tracing, call TraceOff() instead. func (c *Client) TraceErrorsOnlyOff() { c.traceErrorsOnly = false } -// TraceOff - disable HTTP tracing. +// TraceOff disables all HTTP tracing (both normal and errors-only modes). func (c *Client) TraceOff() { // Disable tracing. c.isTraceEnabled = false @@ -620,33 +635,11 @@ func (c *Client) do(req *http.Request) (resp *http.Response, err error) { return resp, nil } -// Peek resp.Body looking for S3 XMl error response: -// - Return the error XML bytes if an error is found -// - Make sure to always restablish the whole http response stream before returning -func tryParseErrRespFromBody(resp *http.Response) ([]byte, error) { - peeker := peeker.NewPeekReadCloser(resp.Body, 5*humanize.MiByte) - defer func() { - peeker.ReplayFromStart() - resp.Body = peeker - }() - - errResp := ErrorResponse{} - errBytes, err := xmlDecodeAndBody(peeker, &errResp) - if err != nil { - var unmarshalErr xml.UnmarshalError - if errors.As(err, &unmarshalErr) { - return nil, nil - } - return nil, err - } - return errBytes, nil -} - // List of success status. -var successStatus = []int{ - http.StatusOK, - http.StatusNoContent, - http.StatusPartialContent, +var successStatus = map[int]struct{}{ + http.StatusOK: {}, + http.StatusNoContent: {}, + http.StatusPartialContent: {}, } // executeMethod - instantiates a given method, and retries the @@ -729,29 +722,15 @@ func (c *Client) executeMethod(ctx context.Context, method string, metadata requ return nil, err } - var success bool - var errBodyBytes []byte - - for _, httpStatus := range successStatus { - if httpStatus == res.StatusCode { - success = true - break - } - } - - if success { - if !metadata.expect200OKWithError { - return res, nil - } - errBodyBytes, err = tryParseErrRespFromBody(res) - if err == nil && len(errBodyBytes) == 0 { - // No S3 XML error is found - return res, nil - } - } else { - errBodyBytes, err = io.ReadAll(res.Body) - } + _, success := successStatus[res.StatusCode] + if success && !metadata.expect200OKWithError { + // We do not expect 2xx to return an error return. + return res, nil + } // in all other situations we must first parse the body as ErrorResponse + // 5MiB is sufficiently large enough to hold any error or regular XML response. + var bodyBytes []byte + bodyBytes, err = io.ReadAll(io.LimitReader(res.Body, 5*humanize.MiByte)) // By now, res.Body should be closed closeResponse(res) if err != nil { @@ -759,16 +738,22 @@ func (c *Client) executeMethod(ctx context.Context, method string, metadata requ } // Save the body. - errBodySeeker := bytes.NewReader(errBodyBytes) - res.Body = io.NopCloser(errBodySeeker) + bodySeeker := bytes.NewReader(bodyBytes) + res.Body = io.NopCloser(bodySeeker) - // For errors verify if its retryable otherwise fail quickly. - errResponse := ToErrorResponse(httpRespToErrorResponse(res, metadata.bucketName, metadata.objectName)) - err = errResponse + apiErr := httpRespToErrorResponse(res, metadata.bucketName, metadata.objectName) // Save the body back again. - errBodySeeker.Seek(0, 0) // Seek back to starting point. - res.Body = io.NopCloser(errBodySeeker) + bodySeeker.Seek(0, 0) // Seek back to starting point. + res.Body = io.NopCloser(bodySeeker) + + if apiErr == nil { + return res, nil + } + + // For errors verify if its retryable otherwise fail quickly. + errResponse := ToErrorResponse(apiErr) + err = errResponse // Bucket region if set in error response and the error // code dictates invalid region, we can retry the request diff --git a/vendor/github.com/minio/minio-go/v7/bucket-cache.go b/vendor/github.com/minio/minio-go/v7/bucket-cache.go index b41902f65..a37a72ae8 100644 --- a/vendor/github.com/minio/minio-go/v7/bucket-cache.go +++ b/vendor/github.com/minio/minio-go/v7/bucket-cache.go @@ -142,7 +142,7 @@ func (c *Client) getBucketLocationRequest(ctx context.Context, bucketName string if h, p, err := net.SplitHostPort(targetURL.Host); err == nil { if targetURL.Scheme == "http" && p == "80" || targetURL.Scheme == "https" && p == "443" { targetURL.Host = h - if ip := net.ParseIP(h); ip != nil && ip.To16() != nil { + if ip := net.ParseIP(h); ip != nil && ip.To4() == nil { targetURL.Host = "[" + h + "]" } } diff --git a/vendor/github.com/minio/minio-go/v7/checksum.go b/vendor/github.com/minio/minio-go/v7/checksum.go index 0691c1fbb..0feb89bf8 100644 --- a/vendor/github.com/minio/minio-go/v7/checksum.go +++ b/vendor/github.com/minio/minio-go/v7/checksum.go @@ -24,13 +24,13 @@ import ( "encoding/binary" "errors" "hash" - "hash/crc32" "io" "math/bits" "net/http" "sort" "strings" + "github.com/klauspost/crc32" "github.com/minio/crc64nvme" ) diff --git a/vendor/github.com/minio/minio-go/v7/code_of_conduct.md b/vendor/github.com/minio/minio-go/v7/code_of_conduct.md index cb232c3c6..7dcdbfc3e 100644 --- a/vendor/github.com/minio/minio-go/v7/code_of_conduct.md +++ b/vendor/github.com/minio/minio-go/v7/code_of_conduct.md @@ -1,80 +1,52 @@ -# Contributor Covenant Code of Conduct +Contributor Covenant Code of Conduct +==================================== -## Our Pledge +Our Pledge +---------- -In the interest of fostering an open and welcoming environment, we as -contributors and maintainers pledge to making participation in our project and -our community a harassment-free experience for everyone, regardless of age, body -size, disability, ethnicity, gender identity and expression, level of experience, -nationality, personal appearance, race, religion, or sexual identity and -orientation. +In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. -## Our Standards +Our Standards +------------- -Examples of behavior that contributes to creating a positive environment -include: +Examples of behavior that contributes to creating a positive environment include: -* Using welcoming and inclusive language -* Being respectful of differing viewpoints and experiences -* Gracefully accepting constructive criticism -* Focusing on what is best for the community -* Showing empathy towards other community members +- Using welcoming and inclusive language +- Being respectful of differing viewpoints and experiences +- Gracefully accepting constructive criticism +- Focusing on what is best for the community +- Showing empathy towards other community members Examples of unacceptable behavior by participants include: -* The use of sexualized language or imagery and unwelcome sexual attention or - advances -* Trolling, insulting/derogatory comments, and personal or political attacks -* Public or private harassment -* Publishing others' private information, such as a physical or electronic - address, without explicit permission -* Other conduct which could reasonably be considered inappropriate in a - professional setting - -## Our Responsibilities - -Project maintainers are responsible for clarifying the standards of acceptable -behavior and are expected to take appropriate and fair corrective action in -response to any instances of unacceptable behavior, in compliance with the -licensing terms applying to the Project developments. - -Project maintainers have the right and responsibility to remove, edit, or -reject comments, commits, code, wiki edits, issues, and other contributions -that are not aligned to this Code of Conduct, or to ban temporarily or -permanently any contributor for other behaviors that they deem inappropriate, -threatening, offensive, or harmful. However, these actions shall respect the -licensing terms of the Project Developments that will always supersede such -Code of Conduct. - -## Scope - -This Code of Conduct applies both within project spaces and in public spaces -when an individual is representing the project or its community. Examples of -representing a project or community include using an official project e-mail -address, posting via an official social media account, or acting as an appointed -representative at an online or offline event. Representation of a project may be -further defined and clarified by project maintainers. - -## Enforcement - -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported by contacting the project team at dev@min.io. The project team -will review and investigate all complaints, and will respond in a way that it deems -appropriate to the circumstances. The project team is obligated to maintain -confidentiality with regard to the reporter of an incident. -Further details of specific enforcement policies may be posted separately. - -Project maintainers who do not follow or enforce the Code of Conduct in good -faith may face temporary or permanent repercussions as determined by other -members of the project's leadership. - -## Attribution - -This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, -available at [http://contributor-covenant.org/version/1/4][version] - -This version includes a clarification to ensure that the code of conduct is in -compliance with the free software licensing terms of the project. - -[homepage]: http://contributor-covenant.org -[version]: http://contributor-covenant.org/version/1/4/ +- The use of sexualized language or imagery and unwelcome sexual attention or advances +- Trolling, insulting/derogatory comments, and personal or political attacks +- Public or private harassment +- Publishing others' private information, such as a physical or electronic address, without explicit permission +- Other conduct which could reasonably be considered inappropriate in a professional setting + +Our Responsibilities +-------------------- + +Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior, in compliance with the licensing terms applying to the Project developments. + +Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. However, these actions shall respect the licensing terms of the Project Developments that will always supersede such Code of Conduct. + +Scope +----- + +This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. + +Enforcement +----------- + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at dev@min.io. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. + +Attribution +----------- + +This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.4, available at [http://contributor-covenant.org/version/1/4](http://contributor-covenant.org/version/1/4/) + +This version includes a clarification to ensure that the code of conduct is in compliance with the free software licensing terms of the project. diff --git a/vendor/github.com/minio/minio-go/v7/create-session.go b/vendor/github.com/minio/minio-go/v7/create-session.go index 676ad21d1..47c286564 100644 --- a/vendor/github.com/minio/minio-go/v7/create-session.go +++ b/vendor/github.com/minio/minio-go/v7/create-session.go @@ -114,7 +114,7 @@ func (c *Client) createSessionRequest(ctx context.Context, bucketName string, se if h, p, err := net.SplitHostPort(host); err == nil { if targetURL.Scheme == "http" && p == "80" || targetURL.Scheme == "https" && p == "443" { host = h - if ip := net.ParseIP(h); ip != nil && ip.To16() != nil { + if ip := net.ParseIP(h); ip != nil && ip.To4() == nil { host = "[" + h + "]" } } diff --git a/vendor/github.com/minio/minio-go/v7/endpoints.go b/vendor/github.com/minio/minio-go/v7/endpoints.go index 00f95d1b5..34b340b39 100644 --- a/vendor/github.com/minio/minio-go/v7/endpoints.go +++ b/vendor/github.com/minio/minio-go/v7/endpoints.go @@ -240,6 +240,10 @@ var awsS3EndpointMap = map[string]awsS3Endpoint{ "s3.mx-central-1.amazonaws.com", "s3.dualstack.mx-central-1.amazonaws.com", }, + "ap-east-2": { + "s3.ap-east-2.amazonaws.com", + "s3.dualstack.ap-east-2.amazonaws.com", + }, } // getS3ExpressEndpoint get Amazon S3 Express endpoing based on the region diff --git a/vendor/github.com/minio/minio-go/v7/functional_tests.go b/vendor/github.com/minio/minio-go/v7/functional_tests.go index 3ade9a6af..4f8f9dd8c 100644 --- a/vendor/github.com/minio/minio-go/v7/functional_tests.go +++ b/vendor/github.com/minio/minio-go/v7/functional_tests.go @@ -88,7 +88,7 @@ func createHTTPTransport() (transport *http.Transport) { transport.TLSClientConfig.InsecureSkipVerify = true } - return + return transport } var readFull = func(r io.Reader, buf []byte) (n int, err error) { @@ -123,7 +123,7 @@ var readFull = func(r io.Reader, buf []byte) (n int, err error) { } else if n > 0 && err == io.EOF { err = io.ErrUnexpectedEOF } - return + return n, err } func baseLogger(testName, function string, args map[string]interface{}, startTime time.Time) *slog.Logger { @@ -282,7 +282,7 @@ var mintDataDir = os.Getenv("MINT_DATA_DIR") func getMintDataDirFilePath(filename string) (fp string) { if mintDataDir == "" { - return + return fp } return filepath.Join(mintDataDir, filename) } @@ -2075,6 +2075,9 @@ func testPutObjectWithChecksums() { cmpChecksum(resp.ChecksumCRC32, meta["x-amz-checksum-crc32"]) cmpChecksum(resp.ChecksumCRC32C, meta["x-amz-checksum-crc32c"]) cmpChecksum(resp.ChecksumCRC64NVME, meta["x-amz-checksum-crc64nvme"]) + if resp.ChecksumMode != minio.ChecksumFullObjectMode.String() { + logError(testName, function, args, startTime, "", "Checksum mode is not full object", fmt.Errorf("got %s, want %s", resp.ChecksumMode, minio.ChecksumFullObjectMode.String())) + } // Read the data back gopts := minio.GetObjectOptions{Checksum: true} @@ -2095,6 +2098,9 @@ func testPutObjectWithChecksums() { cmpChecksum(st.ChecksumCRC32, meta["x-amz-checksum-crc32"]) cmpChecksum(st.ChecksumCRC32C, meta["x-amz-checksum-crc32c"]) cmpChecksum(st.ChecksumCRC64NVME, meta["x-amz-checksum-crc64nvme"]) + if st.ChecksumMode != minio.ChecksumFullObjectMode.String() { + logError(testName, function, args, startTime, "", "Checksum mode is not full object", fmt.Errorf("got %s, want %s", st.ChecksumMode, minio.ChecksumFullObjectMode.String())) + } if st.Size != int64(bufSize) { logError(testName, function, args, startTime, "", "Number of bytes returned by PutObject does not match GetObject, expected "+string(bufSize)+" got "+string(st.Size), err) @@ -2435,7 +2441,10 @@ func testPutMultipartObjectWithChecksums() { reader.Close() h := test.cs.Hasher() h.Reset() - want := hashMultiPart(b, partSize, test.cs) + // wantChksm might be the full object checksum or the multipart checksum, depending on the test.cs type. + wantChksm := hashMultiPart(b, partSize, test.cs) + // wantFullObjectChksm is always the full object checksum that is returned after CopyObject. + wantFullObjectChksm := hashMultiPart(b, len(b), test.cs) rd := bytes.NewReader(b) cs := test.cs @@ -2456,15 +2465,15 @@ func testPutMultipartObjectWithChecksums() { switch test.cs.Base() { case minio.ChecksumCRC32C: - cmpChecksum(resp.ChecksumCRC32C, want) + cmpChecksum(resp.ChecksumCRC32C, wantChksm) case minio.ChecksumCRC32: - cmpChecksum(resp.ChecksumCRC32, want) + cmpChecksum(resp.ChecksumCRC32, wantChksm) case minio.ChecksumSHA1: - cmpChecksum(resp.ChecksumSHA1, want) + cmpChecksum(resp.ChecksumSHA1, wantChksm) case minio.ChecksumSHA256: - cmpChecksum(resp.ChecksumSHA256, want) + cmpChecksum(resp.ChecksumSHA256, wantChksm) case minio.ChecksumCRC64NVME: - cmpChecksum(resp.ChecksumCRC64NVME, want) + cmpChecksum(resp.ChecksumCRC64NVME, wantChksm) } args["section"] = "HeadObject" @@ -2475,15 +2484,51 @@ func testPutMultipartObjectWithChecksums() { } switch test.cs.Base() { case minio.ChecksumCRC32C: - cmpChecksum(st.ChecksumCRC32C, want) + cmpChecksum(st.ChecksumCRC32C, wantChksm) + case minio.ChecksumCRC32: + cmpChecksum(st.ChecksumCRC32, wantChksm) + case minio.ChecksumSHA1: + cmpChecksum(st.ChecksumSHA1, wantChksm) + case minio.ChecksumSHA256: + cmpChecksum(st.ChecksumSHA256, wantChksm) + case minio.ChecksumCRC64NVME: + cmpChecksum(st.ChecksumCRC64NVME, wantChksm) + } + + // Use the CopyObject API to make a copy, in the case it was a composite checksum, + // it will change because the copy is no longer a multipart object. S3 returns the checksum + // of the full object when HeadObject is called on the copy. + args["section"] = "CopyObject" + objectCopyName := objectName + "-copy" + _, err = c.CopyObject(context.Background(), minio.CopyDestOptions{ + Bucket: bucketName, + Object: objectCopyName, + }, minio.CopySrcOptions{ + Bucket: bucketName, + Object: objectName, + }) + if err != nil { + logError(testName, function, args, startTime, "", "CopyObject failed", err) + return + } + + args["section"] = "HeadObject-Copy" + st, err = c.StatObject(context.Background(), bucketName, objectCopyName, minio.StatObjectOptions{Checksum: true}) + if err != nil { + logError(testName, function, args, startTime, "", "StatObject failed", err) + return + } + switch test.cs.Base() { + case minio.ChecksumCRC32C: + cmpChecksum(st.ChecksumCRC32C, wantFullObjectChksm) case minio.ChecksumCRC32: - cmpChecksum(st.ChecksumCRC32, want) + cmpChecksum(st.ChecksumCRC32, wantFullObjectChksm) case minio.ChecksumSHA1: - cmpChecksum(st.ChecksumSHA1, want) + cmpChecksum(st.ChecksumSHA1, wantFullObjectChksm) case minio.ChecksumSHA256: - cmpChecksum(st.ChecksumSHA256, want) + cmpChecksum(st.ChecksumSHA256, wantFullObjectChksm) case minio.ChecksumCRC64NVME: - cmpChecksum(st.ChecksumCRC64NVME, want) + cmpChecksum(st.ChecksumCRC64NVME, wantFullObjectChksm) } args["section"] = "GetObjectAttributes" @@ -2493,19 +2538,19 @@ func testPutMultipartObjectWithChecksums() { return } - if strings.ContainsRune(want, '-') { - want = want[:strings.IndexByte(want, '-')] + if strings.ContainsRune(wantChksm, '-') { + wantChksm = wantChksm[:strings.IndexByte(wantChksm, '-')] } switch test.cs { // Full Object CRC does not return anything with GetObjectAttributes case minio.ChecksumCRC32C: - cmpChecksum(s.Checksum.ChecksumCRC32C, want) + cmpChecksum(s.Checksum.ChecksumCRC32C, wantChksm) case minio.ChecksumCRC32: - cmpChecksum(s.Checksum.ChecksumCRC32, want) + cmpChecksum(s.Checksum.ChecksumCRC32, wantChksm) case minio.ChecksumSHA1: - cmpChecksum(s.Checksum.ChecksumSHA1, want) + cmpChecksum(s.Checksum.ChecksumSHA1, wantChksm) case minio.ChecksumSHA256: - cmpChecksum(s.Checksum.ChecksumSHA256, want) + cmpChecksum(s.Checksum.ChecksumSHA256, wantChksm) } // Read the data back @@ -2529,22 +2574,22 @@ func testPutMultipartObjectWithChecksums() { // Test part 2 checksum... h.Reset() h.Write(b[partSize : 2*partSize]) - want = base64.StdEncoding.EncodeToString(h.Sum(nil)) + wantChksm = base64.StdEncoding.EncodeToString(h.Sum(nil)) switch test.cs { // Full Object CRC does not return any part CRC for whatever reason. case minio.ChecksumCRC32C: - cmpChecksum(st.ChecksumCRC32C, want) + cmpChecksum(st.ChecksumCRC32C, wantChksm) case minio.ChecksumCRC32: - cmpChecksum(st.ChecksumCRC32, want) + cmpChecksum(st.ChecksumCRC32, wantChksm) case minio.ChecksumSHA1: - cmpChecksum(st.ChecksumSHA1, want) + cmpChecksum(st.ChecksumSHA1, wantChksm) case minio.ChecksumSHA256: - cmpChecksum(st.ChecksumSHA256, want) + cmpChecksum(st.ChecksumSHA256, wantChksm) case minio.ChecksumCRC64NVME: // AWS doesn't return part checksum, but may in the future. if st.ChecksumCRC64NVME != "" { - cmpChecksum(st.ChecksumCRC64NVME, want) + cmpChecksum(st.ChecksumCRC64NVME, wantChksm) } } @@ -3321,7 +3366,7 @@ func validateObjectAttributeRequest(OA *minio.ObjectAttributes, opts *minio.Obje if opts.VersionID != "" { if OA.VersionID != opts.VersionID { err = fmt.Errorf("Expected versionId %s but got versionId %s", opts.VersionID, OA.VersionID) - return + return err } } @@ -3348,12 +3393,12 @@ func validateObjectAttributeRequest(OA *minio.ObjectAttributes, opts *minio.Obje if test.HasPartChecksums { if partsMissingChecksum { err = fmt.Errorf("One or all parts were missing a checksum") - return + return err } } else { if foundPartChecksum { err = fmt.Errorf("Did not expect ObjectParts to have checksums but found one") - return + return err } } @@ -3365,52 +3410,52 @@ func validateObjectAttributeRequest(OA *minio.ObjectAttributes, opts *minio.Obje if test.HasFullChecksum { if !hasFullObjectChecksum { err = fmt.Errorf("Full object checksum not found") - return + return err } } else { if hasFullObjectChecksum { err = fmt.Errorf("Did not expect a full object checksum but we got one") - return + return err } } if OA.ETag != test.ETag { err = fmt.Errorf("Etags do not match, got %s but expected %s", OA.ETag, test.ETag) - return + return err } if test.HasParts { if len(OA.ObjectParts.Parts) < 1 { err = fmt.Errorf("Was expecting ObjectParts but none were present") - return + return err } } if OA.StorageClass == "" { err = fmt.Errorf("Was expecting a StorageClass but got none") - return + return err } if OA.ObjectSize != test.ObjectSize { err = fmt.Errorf("Was expecting a ObjectSize but got none") - return + return err } if test.HasParts { if opts.MaxParts == 0 { if len(OA.ObjectParts.Parts) != OA.ObjectParts.PartsCount { err = fmt.Errorf("expected %s parts but got %d", OA.ObjectParts.PartsCount, len(OA.ObjectParts.Parts)) - return + return err } } else if (opts.MaxParts + opts.PartNumberMarker) > OA.ObjectParts.PartsCount { if len(OA.ObjectParts.Parts) != (OA.ObjectParts.PartsCount - opts.PartNumberMarker) { err = fmt.Errorf("expected %d parts but got %d", (OA.ObjectParts.PartsCount - opts.PartNumberMarker), len(OA.ObjectParts.Parts)) - return + return err } } else if opts.MaxParts != 0 { if opts.MaxParts != len(OA.ObjectParts.Parts) { err = fmt.Errorf("expected %d parts but got %d", opts.MaxParts, len(OA.ObjectParts.Parts)) - return + return err } } } @@ -3418,18 +3463,18 @@ func validateObjectAttributeRequest(OA *minio.ObjectAttributes, opts *minio.Obje if OA.ObjectParts.NextPartNumberMarker == OA.ObjectParts.PartsCount { if OA.ObjectParts.IsTruncated { err = fmt.Errorf("Expected ObjectParts to NOT be truncated, but it was") - return + return err } } if OA.ObjectParts.NextPartNumberMarker != OA.ObjectParts.PartsCount { if !OA.ObjectParts.IsTruncated { err = fmt.Errorf("Expected ObjectParts to be truncated, but it was NOT") - return + return err } } - return + return err } // Test PutObject using a large data to trigger multipart readat @@ -3645,6 +3690,93 @@ func testPutObjectStreaming() { logSuccess(testName, function, args, startTime) } +// Test PutObject with preconditions on non-existent objects +func testPutObjectPreconditionOnNonExistent() { + startTime := time.Now() + testName := getFuncName() + function := "PutObject(bucketName, objectName, reader, size, opts) with preconditions" + args := map[string]interface{}{ + "bucketName": "", + "objectName": "", + "opts": "minio.PutObjectOptions{SetMatchETag/SetMatchETagExcept}", + } + + c, err := NewClient(ClientConfig{}) + if err != nil { + logError(testName, function, args, startTime, "", "MinIO client object creation failed", err) + return + } + + bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-") + args["bucketName"] = bucketName + + err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"}) + if err != nil { + logError(testName, function, args, startTime, "", "MakeBucket failed", err) + return + } + + defer cleanupBucket(bucketName, c) + + // Test 1: PutObject with SetMatchETag on non-existent object should fail + objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "test-object-") + args["objectName"] = objectName + + data := bytes.NewReader([]byte("test data")) + + opts := minio.PutObjectOptions{} + opts.SetMatchETag("some-etag") + + _, err = c.PutObject(context.Background(), bucketName, objectName, data, int64(data.Len()), opts) + if err == nil { + logError(testName, function, args, startTime, "", "PutObject with SetMatchETag on non-existent object should have failed", nil) + return + } + + errResp := minio.ToErrorResponse(err) + if errResp.Code != "NoSuchKey" { + logError(testName, function, args, startTime, "", fmt.Sprintf("Expected NoSuchKey error (AWS standard for non-existent objects), got %s", errResp.Code), err) + return + } + + // Test 2: PutObject with SetMatchETagExcept (If-None-Match) on non-existent object should succeed + objectName2 := randString(60, rand.NewSource(time.Now().UnixNano()), "test-object2-") + args["objectName"] = objectName2 + + data2 := bytes.NewReader([]byte("test data 2")) + opts2 := minio.PutObjectOptions{} + opts2.SetMatchETagExcept("some-etag") + + _, err = c.PutObject(context.Background(), bucketName, objectName2, data2, int64(data2.Len()), opts2) + if err != nil { + logError(testName, function, args, startTime, "", "PutObject with SetMatchETagExcept (If-None-Match) on non-existent object should have succeeded", err) + return + } + // Test 3: CompleteMultipartUpload with preconditions on non-existent object should fail + objectName3 := randString(60, rand.NewSource(time.Now().UnixNano()), "test-multipart-") + args["objectName"] = objectName3 + + data3 := bytes.Repeat([]byte("a"), 5*1024*1024+1) + reader3 := bytes.NewReader(data3) + + opts3 := minio.PutObjectOptions{} + opts3.SetMatchETag("non-existent-etag") + + _, err = c.PutObject(context.Background(), bucketName, objectName3, reader3, int64(len(data3)), opts3) + if err == nil { + logError(testName, function, args, startTime, "", "CompleteMultipartUpload with SetMatchETag on non-existent object should have failed", nil) + return + } + + errResp = minio.ToErrorResponse(err) + if errResp.Code != "NoSuchKey" { + logError(testName, function, args, startTime, "", fmt.Sprintf("Expected NoSuchKey error (AWS standard for non-existent objects) for multipart, got %s", errResp.Code), err) + return + } + + logSuccess(testName, function, args, startTime) +} + // Test get object seeker from the end, using whence set to '2'. func testGetObjectSeekEnd() { // initialize logging params @@ -8653,6 +8785,7 @@ func testCopyObjectV2() { logError(testName, function, args, startTime, "", "GetObject failed", err) return } + // Check the various fields of source object against destination object. objInfo, err = r.Stat() if err != nil { @@ -8691,6 +8824,260 @@ func testCopyObjectV2() { logSuccess(testName, function, args, startTime) } +// Tests copy object with various checksum scenarios, tries to not repeat CopyObjectV2 test and +// instead just focus on Checksum. +func testCopyObjectWithChecksums() { + startTime := time.Now() + testName := getFuncName() + function := "CopyObjectWithChecksums(destination, source)" + args := map[string]interface{}{} + + c, err := NewClient(ClientConfig{CredsV2: true}) + if err != nil { + logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) + return + } + + // Generate a new random bucket name. + bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-") + + // Make a new bucket in 'us-east-1' (source bucket). + err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"}) + if err != nil { + logError(testName, function, args, startTime, "", "MakeBucket failed", err) + return + } + defer cleanupBucket(bucketName, c) + + // Make a new bucket in 'us-east-1' (destination bucket). + err = c.MakeBucket(context.Background(), bucketName+"-copy", minio.MakeBucketOptions{Region: "us-east-1"}) + if err != nil { + logError(testName, function, args, startTime, "", "MakeBucket failed", err) + return + } + defer cleanupBucket(bucketName+"-copy", c) + + // Generate 33K of data. + bufSize := dataFileMap["datafile-33-kB"] + reader := getDataReader("datafile-33-kB") + defer reader.Close() + + // PutObject to upload the object to the bucket, this object will have a Crc64NVME checksum applied + // by default since nothing was explicitly specified. + objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "") + _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"}) + if err != nil { + logError(testName, function, args, startTime, "", "PutObject failed", err) + return + } + // GetObject to obtain the eTag + r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{}) + if err != nil { + logError(testName, function, args, startTime, "", "GetObject failed", err) + return + } + objInfo, err := r.Stat() + if err != nil { + logError(testName, function, args, startTime, "", "Stat failed", err) + return + } + r.Close() + + // Copy source options + src := minio.CopySrcOptions{ + Bucket: bucketName, + Object: objectName, + MatchModifiedSince: time.Date(2014, time.April, 0, 0, 0, 0, 0, time.UTC), + MatchETag: objInfo.ETag, + } + + tests := []struct { + csType minio.ChecksumType + cs wantChecksums + }{ + {csType: minio.ChecksumCRC64NVME, cs: wantChecksums{minio.ChecksumCRC64NVME: "iRtfQH3xflQ="}}, + {csType: minio.ChecksumCRC32C, cs: wantChecksums{minio.ChecksumCRC32C: "aHnJMw=="}}, + {csType: minio.ChecksumCRC32, cs: wantChecksums{minio.ChecksumCRC32: "tIZ8hA=="}}, + {csType: minio.ChecksumSHA1, cs: wantChecksums{minio.ChecksumSHA1: "6YIIbcWH1iLaCFqs5vwq5Rwvm+o="}}, + {csType: minio.ChecksumSHA256, cs: wantChecksums{minio.ChecksumSHA256: "GKeJTopbMGPs3h4fAw4oe0R2QnnmFVJeIWkqCkp28Yo="}}, + // In S3, all copied objects without checksums and specified destination checksum algorithms + // automatically gain a CRC-64NVME checksum algorithm. Use ChecksumNone for this case. + {csType: minio.ChecksumNone, cs: wantChecksums{minio.ChecksumCRC64NVME: "iRtfQH3xflQ="}}, + } + + for _, test := range tests { + args := map[string]interface{}{} + args["srcOpts"] = src + args["section"] = "setup" + args["checksum"] = test.csType.String() + + // Copy destination options + bucketCopyName := bucketName + "-copy" + objectCopyName := objectName + "-copy-" + test.csType.String() + dst := minio.CopyDestOptions{ + Bucket: bucketCopyName, + Object: objectCopyName, + ReplaceMetadata: true, + } + if test.csType != minio.ChecksumNone { + // Request the server-side checksum on the copy. + // ChecksumNone is a flag to leave off the header + dst.ChecksumType = test.csType + } + args["destOpts"] = dst + + // Perform the Copy + args["section"] = "CopyObject" + _, err = c.CopyObject(context.Background(), dst, src) + if err != nil { + logError(testName, function, args, startTime, "", "CopyObject failed", err) + return + } + + // Checksum verification + args["section"] = "HeadObject" + st, err := c.StatObject(context.Background(), bucketCopyName, objectCopyName, minio.StatObjectOptions{Checksum: true}) + if err != nil { + logError(testName, function, args, startTime, "", "StatObject failed", err) + return + } + if st.ChecksumMode != "FULL_OBJECT" { + logError(testName, function, args, startTime, "", "ChecksumMode want: FULL_OBJECT, got "+st.ChecksumMode, nil) + return + } + err = cmpChecksum(st, test.cs) + if err != nil { + logError(testName, function, args, startTime, "", "Checksum mismatch", err) + return + } + + logSuccess(testName, function, args, startTime) + } +} + +// Tests replacing an object with CopyObject and a new Checksum type +func testReplaceObjectWithChecksums() { + startTime := time.Now() + testName := getFuncName() + function := "CopyObjectWithChecksums(destination, source)" + args := map[string]interface{}{} + + c, err := NewClient(ClientConfig{CredsV2: true}) + if err != nil { + logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) + return + } + + // Generate a new random bucket name. + bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-") + + // Make a new bucket in 'us-east-1' (source bucket). + err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"}) + if err != nil { + logError(testName, function, args, startTime, "", "MakeBucket failed", err) + return + } + defer cleanupBucket(bucketName, c) + + tests := []struct { + csType minio.ChecksumType + cs wantChecksums + }{ + {csType: minio.ChecksumCRC64NVME, cs: wantChecksums{minio.ChecksumCRC64NVME: "iRtfQH3xflQ="}}, + {csType: minio.ChecksumCRC32C, cs: wantChecksums{minio.ChecksumCRC32C: "aHnJMw=="}}, + {csType: minio.ChecksumCRC32, cs: wantChecksums{minio.ChecksumCRC32: "tIZ8hA=="}}, + {csType: minio.ChecksumSHA1, cs: wantChecksums{minio.ChecksumSHA1: "6YIIbcWH1iLaCFqs5vwq5Rwvm+o="}}, + {csType: minio.ChecksumSHA256, cs: wantChecksums{minio.ChecksumSHA256: "GKeJTopbMGPs3h4fAw4oe0R2QnnmFVJeIWkqCkp28Yo="}}, + // In S3, all copied objects without checksums and specified destination checksum algorithms + // automatically gain a CRC-64NVME checksum algorithm. Use ChecksumNone for this case. + {csType: minio.ChecksumNone, cs: wantChecksums{minio.ChecksumCRC64NVME: "iRtfQH3xflQ="}}, + } + + for _, test := range tests { + args := map[string]interface{}{} + args["section"] = "setup" + args["destOpts"] = "" + args["checksum"] = test.csType.String() + + bufSize := dataFileMap["datafile-33-kB"] + reader := getDataReader("datafile-33-kB") + defer reader.Close() + + // PutObject to upload the object to the bucket + objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "") + _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"}) + if err != nil { + logError(testName, function, args, startTime, "", "PutObject failed", err) + return + } + // GetObject to obtain the eTag + r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{}) + if err != nil { + logError(testName, function, args, startTime, "", "GetObject failed", err) + return + } + objInfo, err := r.Stat() + if err != nil { + logError(testName, function, args, startTime, "", "Stat failed", err) + return + } + r.Close() + + // Copy source options + src := minio.CopySrcOptions{ + Bucket: bucketName, + Object: objectName, + MatchModifiedSince: time.Date(2014, time.April, 0, 0, 0, 0, 0, time.UTC), + MatchETag: objInfo.ETag, + } + + // Copy destination options, overwrite the existing object + dst := minio.CopyDestOptions{ + Bucket: bucketName, + Object: objectName, + // S3 requires that we send some new metadata otherwise it complains that the + // CopyObject is illegal. + UserMetadata: map[string]string{ + "TestMeta": objectName + "-meta-" + test.csType.String(), + }, + ReplaceMetadata: true, + } + if test.csType != minio.ChecksumNone { + // Request the server-side checksum on the copy. + // ChecksumNone is a flag to leave off the header + dst.ChecksumType = test.csType + } + args["destOpts"] = dst + + // Perform the Copy + args["section"] = "CopyObject" + _, err = c.CopyObject(context.Background(), dst, src) + if err != nil { + logError(testName, function, args, startTime, "", "CopyObject failed", err) + return + } + + // Checksum verification + args["section"] = "HeadObject" + st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{Checksum: true}) + if err != nil { + logError(testName, function, args, startTime, "", "StatObject failed", err) + return + } + if st.ChecksumMode != "FULL_OBJECT" { + logError(testName, function, args, startTime, "", "ChecksumMode want: FULL_OBJECT, got "+st.ChecksumMode, nil) + return + } + err = cmpChecksum(st, test.cs) + if err != nil { + logError(testName, function, args, startTime, "", "Checksum mismatch", err) + return + } + + logSuccess(testName, function, args, startTime) + } +} + func testComposeObjectErrorCasesWrapper(c *minio.Client) { // initialize logging params startTime := time.Now() @@ -8976,6 +9363,7 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, testName := getFuncNameLoc(2) function := "CopyObject(destination, source)" args := map[string]interface{}{} + args["testName"] = testName var srcEncryption, dstEncryption encrypt.ServerSide // Make a new bucket in 'us-east-1' (source bucket). @@ -8990,8 +9378,19 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, // 1. create an sse-c encrypted object to copy by uploading const srcSize = 1024 * 1024 buf := bytes.Repeat([]byte("abcde"), srcSize) // gives a buffer of 5MiB + + // Calculate the CRC32C checksum for the object + meta := map[string]string{} + h := minio.ChecksumCRC32C.Hasher() + h.Reset() + h.Write(buf) + meta[minio.ChecksumCRC32C.Key()] = base64.StdEncoding.EncodeToString(h.Sum(nil)) + _, err = c.PutObject(context.Background(), bucketName, "srcObject", bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ ServerSideEncryption: sseSrc, + DisableMultipart: true, + DisableContentSha256: true, + UserMetadata: meta, }) if err != nil { logError(testName, function, args, startTime, "", "PutObject call failed", err) @@ -9028,7 +9427,7 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, } // 3. get copied object and check if content is equal coreClient := minio.Core{Client: c} - reader, _, _, err := coreClient.GetObject(context.Background(), bucketName, "dstObject", minio.GetObjectOptions{ServerSideEncryption: dstEncryption}) + reader, oi, _, err := coreClient.GetObject(context.Background(), bucketName, "dstObject", minio.GetObjectOptions{ServerSideEncryption: dstEncryption, Checksum: true}) if err != nil { logError(testName, function, args, startTime, "", "GetObject failed", err) return @@ -9045,6 +9444,12 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, } reader.Close() + err = cmpChecksum(oi, wantChecksums{minio.ChecksumCRC32C: "bSoobA=="}) + if err != nil { + logError(testName, function, args, startTime, "", "Checksum mismatch on dstObject", err) + return + } + // Test key rotation for source object in-place. var newSSE encrypt.ServerSide if sseSrc != nil && sseSrc.Type() == encrypt.SSEC { @@ -9068,7 +9473,7 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, } // Get copied object and check if content is equal - reader, _, _, err = coreClient.GetObject(context.Background(), bucketName, "srcObject", minio.GetObjectOptions{ServerSideEncryption: newSSE}) + reader, oi, _, err = coreClient.GetObject(context.Background(), bucketName, "srcObject", minio.GetObjectOptions{ServerSideEncryption: newSSE, Checksum: true}) if err != nil { logError(testName, function, args, startTime, "", "GetObject failed", err) return @@ -9085,6 +9490,13 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, } reader.Close() + err = cmpChecksum(oi, wantChecksums{minio.ChecksumCRC32C: "bSoobA=="}) + if err != nil { + fmt.Printf("srcObject objectInfo: %+v\n", oi) + logError(testName, function, args, startTime, "", "Checksum mismatch on srcObject for in-place", err) + return + } + // Test in-place decryption. dst = minio.CopyDestOptions{ Bucket: bucketName, @@ -9106,7 +9518,7 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, } // Get copied decrypted object and check if content is equal - reader, _, _, err = coreClient.GetObject(context.Background(), bucketName, "srcObject", minio.GetObjectOptions{}) + reader, oi, _, err = coreClient.GetObject(context.Background(), bucketName, "srcObject", minio.GetObjectOptions{Checksum: true}) if err != nil { logError(testName, function, args, startTime, "", "GetObject failed", err) return @@ -9123,6 +9535,12 @@ func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, return } + err = cmpChecksum(oi, wantChecksums{minio.ChecksumCRC32C: "bSoobA=="}) + if err != nil { + logError(testName, function, args, startTime, "", "Checksum mismatch for decrypted object", err) + return + } + logSuccess(testName, function, args, startTime) } @@ -9134,7 +9552,7 @@ func testUnencryptedToSSECCopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9154,7 +9572,7 @@ func testUnencryptedToSSES3CopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9175,7 +9593,7 @@ func testUnencryptedToUnencryptedCopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9195,7 +9613,7 @@ func testEncryptedSSECToSSECCopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9216,7 +9634,7 @@ func testEncryptedSSECToSSES3CopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9237,7 +9655,7 @@ func testEncryptedSSECToUnencryptedCopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9258,7 +9676,7 @@ func testEncryptedSSES3ToSSECCopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9279,7 +9697,7 @@ func testEncryptedSSES3ToSSES3CopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9300,7 +9718,7 @@ func testEncryptedSSES3ToUnencryptedCopyObject() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{}) + c, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -9321,7 +9739,7 @@ func testEncryptedCopyObjectV2() { function := "CopyObject(destination, source)" args := map[string]interface{}{} - c, err := NewClient(ClientConfig{CredsV2: true}) + c, err := NewClient(ClientConfig{CredsV2: true, TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err) return @@ -10080,7 +10498,7 @@ func testUnencryptedToSSECCopyObjectPart() { function := "CopyObjectPart(destination, source)" args := map[string]interface{}{} - client, err := NewClient(ClientConfig{}) + client, err := NewClient(ClientConfig{TrailingHeaders: true}) if err != nil { logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err) return @@ -11080,7 +11498,7 @@ func testUserMetadataCopyingWrapper(c *minio.Client) { objInfo, err := c.StatObject(context.Background(), bucketName, object, minio.StatObjectOptions{}) if err != nil { logError(testName, function, args, startTime, "", "Stat failed", err) - return + return h } h = make(http.Header) for k, vs := range objInfo.Metadata { @@ -11256,7 +11674,7 @@ func testStorageClassMetadataPutObject() { objInfo, err := c.StatObject(context.Background(), bucketName, object, minio.StatObjectOptions{}) if err != nil { logError(testName, function, args, startTime, "", "Stat failed", err) - return + return h } h = make(http.Header) for k, vs := range objInfo.Metadata { @@ -11377,7 +11795,7 @@ func testStorageClassMetadataCopyObject() { args["object"] = object if err != nil { logError(testName, function, args, startTime, "", "Stat failed", err) - return + return h } h = make(http.Header) for k, vs := range objInfo.Metadata { @@ -14195,6 +14613,29 @@ func mustParseBool(str string) bool { return b } +// wantChecksums is a map of expected checksums for an object. +type wantChecksums map[minio.ChecksumType]string + +// cmpChecksum compares the checksums of an object against expected values. +func cmpChecksum(oi minio.ObjectInfo, chksums wantChecksums) error { + if oi.ChecksumCRC64NVME != chksums[minio.ChecksumCRC64NVME] { + return fmt.Errorf("Checksum mismatch for CRC64NVME, want: %s, got: %s", chksums[minio.ChecksumCRC64NVME], oi.ChecksumCRC64NVME) + } + if oi.ChecksumCRC32C != chksums[minio.ChecksumCRC32C] { + return fmt.Errorf("Checksum mismatch for CRC32C, want: %s, got: %s", chksums[minio.ChecksumCRC32C], oi.ChecksumCRC32C) + } + if oi.ChecksumCRC32 != chksums[minio.ChecksumCRC32] { + return fmt.Errorf("Checksum mismatch for CRC32, want: %s, got: %s", chksums[minio.ChecksumCRC32], oi.ChecksumCRC32) + } + if oi.ChecksumSHA1 != chksums[minio.ChecksumSHA1] { + return fmt.Errorf("Checksum mismatch for SHA1, want: %s, got: %s", chksums[minio.ChecksumSHA1], oi.ChecksumSHA1) + } + if oi.ChecksumSHA256 != chksums[minio.ChecksumSHA256] { + return fmt.Errorf("Checksum mismatch for SHA256, want: %s, got: %s", chksums[minio.ChecksumSHA256], oi.ChecksumSHA256) + } + return nil +} + func main() { slog.SetDefault(slog.New(slog.NewJSONHandler( os.Stdout, @@ -14219,6 +14660,8 @@ func main() { // execute tests if isFullMode() { + testCopyObjectWithChecksums() + testReplaceObjectWithChecksums() testCorsSetGetDelete() testCors() testListMultipartUpload() @@ -14253,6 +14696,7 @@ func main() { testPutObjectWithMetadata() testPutObjectReadAt() testPutObjectStreaming() + testPutObjectPreconditionOnNonExistent() testGetObjectSeekEnd() testGetObjectClosedTwice() testGetObjectS3Zip() diff --git a/vendor/github.com/minio/minio-go/v7/internal/json/json_goccy.go b/vendor/github.com/minio/minio-go/v7/internal/json/json_goccy.go deleted file mode 100644 index 8fc33849f..000000000 --- a/vendor/github.com/minio/minio-go/v7/internal/json/json_goccy.go +++ /dev/null @@ -1,49 +0,0 @@ -//go:build !stdlibjson - -/* - * MinIO Go Library for Amazon S3 Compatible Cloud Storage - * Copyright 2025 MinIO, Inc. - * - * 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. - */ - -package json - -import "github.com/goccy/go-json" - -// This file defines the JSON functions used internally and forwards them -// to goccy/go-json. Alternatively, the standard library can be used by setting -// the build tag stdlibjson. This can be useful for testing purposes or if -// goccy/go-json causes issues. -// -// This file does not contain all definitions from goccy/go-json; if needed, more -// can be added, but keep in mind that json_stdlib.go will also need to be -// updated. - -var ( - // Unmarshal is a wrapper around goccy/go-json Unmarshal function. - Unmarshal = json.Unmarshal - // Marshal is a wrapper around goccy/go-json Marshal function. - Marshal = json.Marshal - // NewEncoder is a wrapper around goccy/go-json NewEncoder function. - NewEncoder = json.NewEncoder - // NewDecoder is a wrapper around goccy/go-json NewDecoder function. - NewDecoder = json.NewDecoder -) - -type ( - // Encoder is an alias for goccy/go-json Encoder. - Encoder = json.Encoder - // Decoder is an alias for goccy/go-json Decoder. - Decoder = json.Decoder -) diff --git a/vendor/github.com/minio/minio-go/v7/internal/json/json_stdlib.go b/vendor/github.com/minio/minio-go/v7/internal/json/json_stdlib.go deleted file mode 100644 index a671fead3..000000000 --- a/vendor/github.com/minio/minio-go/v7/internal/json/json_stdlib.go +++ /dev/null @@ -1,49 +0,0 @@ -//go:build stdlibjson - -/* - * MinIO Go Library for Amazon S3 Compatible Cloud Storage - * Copyright 2025 MinIO, Inc. - * - * 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. - */ - -package json - -import "encoding/json" - -// This file defines the JSON functions used internally and forwards them -// to encoding/json. This is only enabled by setting the build tag stdlibjson, -// otherwise json_goccy.go applies. -// This can be useful for testing purposes or if goccy/go-json (which is used otherwise) causes issues. -// -// This file does not contain all definitions from encoding/json; if needed, more -// can be added, but keep in mind that json_goccy.go will also need to be -// updated. - -var ( - // Unmarshal is a wrapper around encoding/json Unmarshal function. - Unmarshal = json.Unmarshal - // Marshal is a wrapper around encoding/json Marshal function. - Marshal = json.Marshal - // NewEncoder is a wrapper around encoding/json NewEncoder function. - NewEncoder = json.NewEncoder - // NewDecoder is a wrapper around encoding/json NewDecoder function. - NewDecoder = json.NewDecoder -) - -type ( - // Encoder is an alias for encoding/json Encoder. - Encoder = json.Encoder - // Decoder is an alias for encoding/json Decoder. - Decoder = json.Decoder -) diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go index c9a52252a..0c83fc7fa 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go @@ -18,6 +18,7 @@ package credentials import ( + "encoding/json" "errors" "os" "os/exec" @@ -26,7 +27,6 @@ import ( "time" "github.com/go-ini/ini" - "github.com/minio/minio-go/v7/internal/json" ) // A externalProcessCredentials stores the output of a credential_process diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go index 398952ee9..b78dcaccf 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go @@ -18,11 +18,10 @@ package credentials import ( + "encoding/json" "os" "path/filepath" "runtime" - - "github.com/minio/minio-go/v7/internal/json" ) // A FileMinioClient retrieves credentials from the current user's home diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go index edc988467..f4f7c8f7e 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go @@ -20,6 +20,7 @@ package credentials import ( "bufio" "context" + "encoding/json" "errors" "fmt" "io" @@ -30,8 +31,6 @@ import ( "path" "strings" "time" - - "github.com/minio/minio-go/v7/internal/json" ) // DefaultExpiryWindow - Default expiry window. diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go index 162f460ee..e9e7a1151 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go @@ -132,7 +132,7 @@ func (c *CustomTokenIdentity) RetrieveWithCredContext(cc *CredContext) (value Va r := AssumeRoleWithCustomTokenResponse{} if err = xml.NewDecoder(resp.Body).Decode(&r); err != nil { - return + return value, err } cr := r.Result.Credentials diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go index 31fe10ae0..7e80cd6a2 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go @@ -74,6 +74,9 @@ type LDAPIdentity struct { // requested from LDAP. RequestedExpiry time.Duration + // Optional, if empty applies to default config + ConfigName string + // Optional, used for token revokation TokenRevokeType string } @@ -110,6 +113,13 @@ func LDAPIdentityExpiryOpt(d time.Duration) LDAPIdentityOpt { } } +// LDAPIdentityConfigNameOpt sets the config name for requested credentials. +func LDAPIdentityConfigNameOpt(name string) LDAPIdentityOpt { + return func(k *LDAPIdentity) { + k.ConfigName = name + } +} + // NewLDAPIdentityWithSessionPolicy returns new credentials object that uses // LDAP Identity with a specified session policy. The `policy` parameter must be // a JSON string specifying the policy document. @@ -158,6 +168,9 @@ func (k *LDAPIdentity) RetrieveWithCredContext(cc *CredContext) (value Value, er if k.TokenRevokeType != "" { v.Set("TokenRevokeType", k.TokenRevokeType) } + if k.ConfigName != "" { + v.Set("ConfigName", k.ConfigName) + } req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(v.Encode())) if err != nil { @@ -201,7 +214,7 @@ func (k *LDAPIdentity) RetrieveWithCredContext(cc *CredContext) (value Value, er r := AssumeRoleWithLDAPResponse{} if err = xml.NewDecoder(resp.Body).Decode(&r); err != nil { - return + return value, err } cr := r.Result.Credentials diff --git a/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go index 1fc510ae0..0a8a7baa2 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go @@ -20,10 +20,10 @@ package encrypt import ( "crypto/md5" "encoding/base64" + "encoding/json" "errors" "net/http" - "github.com/minio/minio-go/v7/internal/json" "golang.org/x/crypto/argon2" ) diff --git a/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go b/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go index cf1ba038f..7ed98b0d1 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go @@ -19,11 +19,10 @@ package lifecycle import ( + "encoding/json" "encoding/xml" "errors" "time" - - "github.com/minio/minio-go/v7/internal/json" ) var errMissingStorageClass = errors.New("storage-class cannot be empty") diff --git a/vendor/github.com/minio/minio-go/v7/pkg/peeker/peek-reader-closer.go b/vendor/github.com/minio/minio-go/v7/pkg/peeker/peek-reader-closer.go deleted file mode 100644 index 26c9cf637..000000000 --- a/vendor/github.com/minio/minio-go/v7/pkg/peeker/peek-reader-closer.go +++ /dev/null @@ -1,73 +0,0 @@ -/* - * MinIO Go Library for Amazon S3 Compatible Cloud Storage - * Copyright 2015-2025 MinIO, Inc. - * - * 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. - */ - -package peeker - -import ( - "bytes" - "errors" - "io" -) - -// PeekReadCloser offers a way to peek a ReadCloser stream and then -// return the exact stream of the underlying ReadCloser -type PeekReadCloser struct { - io.ReadCloser - - recordMode bool - recordMaxBuf int - recordBuf *bytes.Buffer -} - -// ReplayFromStart ensures next Read() will restart to stream the -// underlying ReadCloser stream from the beginning -func (prc *PeekReadCloser) ReplayFromStart() { - prc.recordMode = false -} - -func (prc *PeekReadCloser) Read(p []byte) (int, error) { - if prc.recordMode { - if prc.recordBuf.Len() > prc.recordMaxBuf { - return 0, errors.New("maximum peek buffer exceeded") - } - n, err := prc.ReadCloser.Read(p) - prc.recordBuf.Write(p[:n]) - return n, err - } - // Replay mode - if prc.recordBuf.Len() > 0 { - pn, _ := prc.recordBuf.Read(p) - return pn, nil - } - return prc.ReadCloser.Read(p) -} - -// Close releases the record buffer memory and close the underlying ReadCloser -func (prc *PeekReadCloser) Close() error { - prc.recordBuf.Reset() - return prc.ReadCloser.Close() -} - -// NewPeekReadCloser returns a new peek reader -func NewPeekReadCloser(rc io.ReadCloser, maxBufSize int) *PeekReadCloser { - return &PeekReadCloser{ - ReadCloser: rc, - recordMode: true, // recording mode by default - recordBuf: bytes.NewBuffer(make([]byte, 0, 1024)), - recordMaxBuf: maxBufSize, - } -} diff --git a/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go b/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go index 2f7993f4b..cc17a3531 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go @@ -1014,7 +1014,7 @@ func (q ReplQueueStats) QStats() (r ReplQStats) { if len(q.Nodes) > 0 { r.Uptime /= int64(len(q.Nodes)) // average uptime } - return + return r } // MetricsV2 represents replication metrics for a bucket. diff --git a/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go b/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go index 8aa92212b..c12651b54 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go @@ -18,10 +18,9 @@ package set import ( + "encoding/json" "fmt" "sort" - - "github.com/minio/minio-go/v7/internal/json" ) // StringSet - uses map as set of strings. diff --git a/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go index f65c36c7d..d15c99ad7 100644 --- a/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go +++ b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go @@ -48,11 +48,11 @@ func encodeURL2Path(req *http.Request, virtualHost bool) (path string) { path = "/" + bucketName path += req.URL.Path path = s3utils.EncodePath(path) - return + return path } } path = s3utils.EncodePath(req.URL.Path) - return + return path } // PreSignV2 - presign the request in following style. diff --git a/vendor/github.com/minio/minio-go/v7/utils.go b/vendor/github.com/minio/minio-go/v7/utils.go index cc96005b9..6c8dc9433 100644 --- a/vendor/github.com/minio/minio-go/v7/utils.go +++ b/vendor/github.com/minio/minio-go/v7/utils.go @@ -80,7 +80,7 @@ func amzRestoreToStruct(restore string) (ongoing bool, expTime time.Time, err er return false, time.Time{}, err } } - return + return ongoing, expTime, err } // xmlDecoder provide decoded value in xml. @@ -438,7 +438,7 @@ var readFull = func(r io.Reader, buf []byte) (n int, err error) { } else if n > 0 && err == io.EOF { err = io.ErrUnexpectedEOF } - return + return n, err } // regCred matches credential string in HTTP header diff --git a/vendor/github.com/ncruces/go-sqlite3/config.go b/vendor/github.com/ncruces/go-sqlite3/config.go index 153fbd654..b390ffa8b 100644 --- a/vendor/github.com/ncruces/go-sqlite3/config.go +++ b/vendor/github.com/ncruces/go-sqlite3/config.go @@ -265,7 +265,7 @@ func traceCallback(ctx context.Context, mod api.Module, evt TraceEvent, pDB, pAr } } if arg1 != nil { - _, rc = errorCode(c.trace(evt, arg1, arg2), ERROR) + _ = c.trace(evt, arg1, arg2) } } return rc diff --git a/vendor/github.com/ncruces/go-sqlite3/conn.go b/vendor/github.com/ncruces/go-sqlite3/conn.go index a7eca1652..5794b16ec 100644 --- a/vendor/github.com/ncruces/go-sqlite3/conn.go +++ b/vendor/github.com/ncruces/go-sqlite3/conn.go @@ -420,21 +420,21 @@ func busyCallback(ctx context.Context, mod api.Module, pDB ptr_t, count int32) ( // Status retrieves runtime status information about a database connection. // // https://sqlite.org/c3ref/db_status.html -func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err error) { +func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int64, err error) { defer c.arena.mark()() - hiPtr := c.arena.new(intlen) - curPtr := c.arena.new(intlen) + hiPtr := c.arena.new(8) + curPtr := c.arena.new(8) var i int32 if reset { i = 1 } - rc := res_t(c.call("sqlite3_db_status", stk_t(c.handle), + rc := res_t(c.call("sqlite3_db_status64", stk_t(c.handle), stk_t(op), stk_t(curPtr), stk_t(hiPtr), stk_t(i))) if err = c.error(rc); err == nil { - current = int(util.Read32[int32](c.mod, curPtr)) - highwater = int(util.Read32[int32](c.mod, hiPtr)) + current = util.Read64[int64](c.mod, curPtr) + highwater = util.Read64[int64](c.mod, hiPtr) } return } diff --git a/vendor/github.com/ncruces/go-sqlite3/const.go b/vendor/github.com/ncruces/go-sqlite3/const.go index 4a4dfeb2f..a5d92b583 100644 --- a/vendor/github.com/ncruces/go-sqlite3/const.go +++ b/vendor/github.com/ncruces/go-sqlite3/const.go @@ -73,6 +73,9 @@ const ( ERROR_MISSING_COLLSEQ ExtendedErrorCode = xErrorCode(ERROR) | (1 << 8) ERROR_RETRY ExtendedErrorCode = xErrorCode(ERROR) | (2 << 8) ERROR_SNAPSHOT ExtendedErrorCode = xErrorCode(ERROR) | (3 << 8) + ERROR_RESERVESIZE ExtendedErrorCode = xErrorCode(ERROR) | (4 << 8) + ERROR_KEY ExtendedErrorCode = xErrorCode(ERROR) | (5 << 8) + ERROR_UNABLE ExtendedErrorCode = xErrorCode(ERROR) | (6 << 8) IOERR_READ ExtendedErrorCode = xErrorCode(IOERR) | (1 << 8) IOERR_SHORT_READ ExtendedErrorCode = xErrorCode(IOERR) | (2 << 8) IOERR_WRITE ExtendedErrorCode = xErrorCode(IOERR) | (3 << 8) @@ -107,6 +110,8 @@ const ( IOERR_DATA ExtendedErrorCode = xErrorCode(IOERR) | (32 << 8) IOERR_CORRUPTFS ExtendedErrorCode = xErrorCode(IOERR) | (33 << 8) IOERR_IN_PAGE ExtendedErrorCode = xErrorCode(IOERR) | (34 << 8) + IOERR_BADKEY ExtendedErrorCode = xErrorCode(IOERR) | (35 << 8) + IOERR_CODEC ExtendedErrorCode = xErrorCode(IOERR) | (36 << 8) LOCKED_SHAREDCACHE ExtendedErrorCode = xErrorCode(LOCKED) | (1 << 8) LOCKED_VTAB ExtendedErrorCode = xErrorCode(LOCKED) | (2 << 8) BUSY_RECOVERY ExtendedErrorCode = xErrorCode(BUSY) | (1 << 8) @@ -229,7 +234,8 @@ const ( DBSTATUS_DEFERRED_FKS DBStatus = 10 DBSTATUS_CACHE_USED_SHARED DBStatus = 11 DBSTATUS_CACHE_SPILL DBStatus = 12 - // DBSTATUS_MAX DBStatus = 12 + DBSTATUS_TEMPBUF_SPILL DBStatus = 13 + // DBSTATUS_MAX DBStatus = 13 ) // DBConfig are the available database connection configuration options. @@ -362,13 +368,14 @@ const ( // CheckpointMode are all the checkpoint mode values. // // https://sqlite.org/c3ref/c_checkpoint_full.html -type CheckpointMode uint32 +type CheckpointMode int32 const ( - CHECKPOINT_PASSIVE CheckpointMode = 0 /* Do as much as possible w/o blocking */ - CHECKPOINT_FULL CheckpointMode = 1 /* Wait for writers, then checkpoint */ - CHECKPOINT_RESTART CheckpointMode = 2 /* Like FULL but wait for readers */ - CHECKPOINT_TRUNCATE CheckpointMode = 3 /* Like RESTART but also truncate WAL */ + CHECKPOINT_NOOP CheckpointMode = -1 /* Do no work at all */ + CHECKPOINT_PASSIVE CheckpointMode = 0 /* Do as much as possible w/o blocking */ + CHECKPOINT_FULL CheckpointMode = 1 /* Wait for writers, then checkpoint */ + CHECKPOINT_RESTART CheckpointMode = 2 /* Like FULL but wait for readers */ + CHECKPOINT_TRUNCATE CheckpointMode = 3 /* Like RESTART but also truncate WAL */ ) // TxnState are the allowed return values from [Conn.TxnState]. diff --git a/vendor/github.com/ncruces/go-sqlite3/context.go b/vendor/github.com/ncruces/go-sqlite3/context.go index 269bf52f9..f7a8cc557 100644 --- a/vendor/github.com/ncruces/go-sqlite3/context.go +++ b/vendor/github.com/ncruces/go-sqlite3/context.go @@ -198,14 +198,14 @@ func (ctx Context) ResultError(err error) { return } - msg, code := errorCode(err, _OK) + msg, code := errorCode(err, ERROR) if msg != "" { defer ctx.c.arena.mark()() ptr := ctx.c.arena.string(msg) ctx.c.call("sqlite3_result_error", stk_t(ctx.handle), stk_t(ptr), stk_t(len(msg))) } - if code != _OK { + if code != res_t(ERROR) { ctx.c.call("sqlite3_result_error_code", stk_t(ctx.handle), stk_t(code)) } diff --git a/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt b/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt index bb049c219..8a1345039 100644 --- a/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt +++ b/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt @@ -59,7 +59,7 @@ sqlite3_db_filename sqlite3_db_name sqlite3_db_readonly sqlite3_db_release_memory -sqlite3_db_status +sqlite3_db_status64 sqlite3_declare_vtab sqlite3_errcode sqlite3_errmsg diff --git a/vendor/github.com/ncruces/go-sqlite3/embed/sqlite3.wasm b/vendor/github.com/ncruces/go-sqlite3/embed/sqlite3.wasm Binary files differindex e44b2cc9f..8d094140b 100644 --- a/vendor/github.com/ncruces/go-sqlite3/embed/sqlite3.wasm +++ b/vendor/github.com/ncruces/go-sqlite3/embed/sqlite3.wasm diff --git a/vendor/github.com/ncruces/go-sqlite3/error.go b/vendor/github.com/ncruces/go-sqlite3/error.go index 83b057d0d..8d0419c51 100644 --- a/vendor/github.com/ncruces/go-sqlite3/error.go +++ b/vendor/github.com/ncruces/go-sqlite3/error.go @@ -11,6 +11,7 @@ import ( // // https://sqlite.org/c3ref/errcode.html type Error struct { + sys error msg string sql string code res_t @@ -33,16 +34,28 @@ func (e *Error) ExtendedCode() ExtendedErrorCode { // Error implements the error interface. func (e *Error) Error() string { var b strings.Builder - b.WriteString(util.ErrorCodeString(uint32(e.code))) + b.WriteString(util.ErrorCodeString(e.code)) if e.msg != "" { b.WriteString(": ") b.WriteString(e.msg) } + if e.sys != nil { + b.WriteString(": ") + b.WriteString(e.sys.Error()) + } return b.String() } +// Unwrap returns the underlying operating system error +// that caused the I/O error or failure to open a file. +// +// https://sqlite.org/c3ref/system_errno.html +func (e *Error) Unwrap() error { + return e.sys +} + // Is tests whether this error matches a given [ErrorCode] or [ExtendedErrorCode]. // // It makes it possible to do: @@ -90,7 +103,16 @@ func (e *Error) SQL() string { // Error implements the error interface. func (e ErrorCode) Error() string { - return util.ErrorCodeString(uint32(e)) + return util.ErrorCodeString(e) +} + +// As converts this error to an [ExtendedErrorCode]. +func (e ErrorCode) As(err any) bool { + c, ok := err.(*xErrorCode) + if ok { + *c = xErrorCode(e) + } + return ok } // Temporary returns true for [BUSY] errors. @@ -105,7 +127,7 @@ func (e ErrorCode) ExtendedCode() ExtendedErrorCode { // Error implements the error interface. func (e ExtendedErrorCode) Error() string { - return util.ErrorCodeString(uint32(e)) + return util.ErrorCodeString(e) } // Is tests whether this error matches a given [ErrorCode]. @@ -150,14 +172,10 @@ func errorCode(err error, def ErrorCode) (msg string, code res_t) { return code.msg, res_t(code.code) } - var ecode ErrorCode var xcode xErrorCode - switch { - case errors.As(err, &xcode): + if errors.As(err, &xcode) { code = res_t(xcode) - case errors.As(err, &ecode): - code = res_t(ecode) - default: + } else { code = res_t(def) } return err.Error(), code diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go index 5e89018dd..031a702b9 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go @@ -39,6 +39,9 @@ const ( ERROR_MISSING_COLLSEQ = ERROR | (1 << 8) ERROR_RETRY = ERROR | (2 << 8) ERROR_SNAPSHOT = ERROR | (3 << 8) + ERROR_RESERVESIZE = ERROR | (4 << 8) + ERROR_KEY = ERROR | (5 << 8) + ERROR_UNABLE = ERROR | (6 << 8) IOERR_READ = IOERR | (1 << 8) IOERR_SHORT_READ = IOERR | (2 << 8) IOERR_WRITE = IOERR | (3 << 8) @@ -73,6 +76,8 @@ const ( IOERR_DATA = IOERR | (32 << 8) IOERR_CORRUPTFS = IOERR | (33 << 8) IOERR_IN_PAGE = IOERR | (34 << 8) + IOERR_BADKEY = IOERR | (35 << 8) + IOERR_CODEC = IOERR | (36 << 8) LOCKED_SHAREDCACHE = LOCKED | (1 << 8) LOCKED_VTAB = LOCKED | (2 << 8) BUSY_RECOVERY = BUSY | (1 << 8) diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go index 76769ed2e..d9bce5b80 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go @@ -33,8 +33,12 @@ func AssertErr() ErrorString { return ErrorString(msg) } -func ErrorCodeString(rc uint32) string { - switch rc { +type errorCode interface { + ~uint8 | ~uint16 | ~uint32 | ~int32 +} + +func ErrorCodeString[T errorCode](rc T) string { + switch uint32(rc) { case ABORT_ROLLBACK: return "sqlite3: abort due to ROLLBACK" case ROW: @@ -42,7 +46,7 @@ func ErrorCodeString(rc uint32) string { case DONE: return "sqlite3: no more rows available" } - switch rc & 0xff { + switch uint8(rc) { case OK: return "sqlite3: not an error" case ERROR: diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go index ba5754a32..a308b4e23 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go @@ -12,6 +12,7 @@ type ConnKey struct{} type moduleKey struct{} type moduleState struct { + sysError error mmapState handleState } @@ -23,3 +24,20 @@ func NewContext(ctx context.Context) context.Context { ctx = context.WithValue(ctx, moduleKey{}, state) return ctx } + +func GetSystemError(ctx context.Context) error { + // Test needed to simplify testing. + s, ok := ctx.Value(moduleKey{}).(*moduleState) + if ok { + return s.sysError + } + return nil +} + +func SetSystemError(ctx context.Context, err error) { + // Test needed to simplify testing. + s, ok := ctx.Value(moduleKey{}).(*moduleState) + if ok { + s.sysError = err + } +} diff --git a/vendor/github.com/ncruces/go-sqlite3/sqlite.go b/vendor/github.com/ncruces/go-sqlite3/sqlite.go index fb64ac5c0..52532e077 100644 --- a/vendor/github.com/ncruces/go-sqlite3/sqlite.go +++ b/vendor/github.com/ncruces/go-sqlite3/sqlite.go @@ -125,14 +125,15 @@ func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error { panic(util.OOMErr) } + var msg, query string if handle != 0 { - var msg, query string if ptr := ptr_t(sqlt.call("sqlite3_errmsg", stk_t(handle))); ptr != 0 { msg = util.ReadString(sqlt.mod, ptr, _MAX_LENGTH) - if msg == "not an error" { + msg = strings.TrimPrefix(msg, "sqlite3: ") + msg = strings.TrimPrefix(msg, util.ErrorCodeString(rc)[len("sqlite3: "):]) + msg = strings.TrimPrefix(msg, ": ") + if msg == "" || msg == "not an error" { msg = "" - } else { - msg = strings.TrimPrefix(msg, util.ErrorCodeString(uint32(rc))[len("sqlite3: "):]) } } @@ -141,10 +142,16 @@ func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error { query = sql[0][i:] } } + } - if msg != "" || query != "" { - return &Error{code: rc, msg: msg, sql: query} - } + var sys error + switch ErrorCode(rc) { + case CANTOPEN, IOERR: + sys = util.GetSystemError(sqlt.ctx) + } + + if sys != nil || msg != "" || query != "" { + return &Error{code: rc, sys: sys, msg: msg, sql: query} } return xErrorCode(rc) } diff --git a/vendor/github.com/ncruces/go-sqlite3/util/sql3util/wasm/sql3parse_table.wasm b/vendor/github.com/ncruces/go-sqlite3/util/sql3util/wasm/sql3parse_table.wasm Binary files differindex 824a7bf97..198f1007f 100644 --- a/vendor/github.com/ncruces/go-sqlite3/util/sql3util/wasm/sql3parse_table.wasm +++ b/vendor/github.com/ncruces/go-sqlite3/util/sql3util/wasm/sql3parse_table.wasm diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/README.md b/vendor/github.com/ncruces/go-sqlite3/vfs/README.md index 68cb92dcc..f34e08b64 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/README.md +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/README.md @@ -20,11 +20,12 @@ The main differences to be aware of are ### File Locking POSIX advisory locks, -which SQLite uses on [Unix](https://github.com/sqlite/sqlite/blob/5d60f4/src/os_unix.c#L13-L14), -are [broken by design](https://github.com/sqlite/sqlite/blob/5d60f4/src/os_unix.c#L1074-L1162). +which SQLite uses on [Unix](https://github.com/sqlite/sqlite/blob/41fda52/src/os_unix.c#L13-L14), +are [broken by design](https://github.com/sqlite/sqlite/blob/41fda52/src/os_unix.c#L1188-L1276). Instead, on Linux and macOS, this package uses -[OFD locks](https://gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html) +[OFD locks](https://sourceware.org/glibc/manual/2.25/html_node/Open-File-Description-Locks.html) to synchronize access to database files. +OFD locks require [Linux 3.15](https://lwn.net/Articles/586904/). This package can also use [BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2), @@ -73,7 +74,7 @@ to check if your build supports shared memory. ### Blocking Locks -On Windows and macOS, this package implements +On macOS, this package implements [Wal-mode blocking locks](https://sqlite.org/src/doc/tip/doc/wal-lock.md). ### Batch-Atomic Write diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/api.go b/vendor/github.com/ncruces/go-sqlite3/vfs/api.go index a0d36b214..4f4f833bb 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/api.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/api.go @@ -10,7 +10,8 @@ import ( // A VFS defines the interface between the SQLite core and the underlying operating system. // -// Use sqlite3.ErrorCode or sqlite3.ExtendedErrorCode to return specific error codes to SQLite. +// Use [SystemError], sqlite3.ErrorCode, or sqlite3.ExtendedErrorCode +// to return specific error codes to SQLite. // // https://sqlite.org/c3ref/vfs.html type VFS interface { @@ -31,8 +32,9 @@ type VFSFilename interface { // A File represents an open file in the OS interface layer. // -// Use sqlite3.ErrorCode or sqlite3.ExtendedErrorCode to return specific error codes to SQLite. -// In particular, sqlite3.BUSY is necessary to correctly implement lock methods. +// Use [SystemError], sqlite3.ErrorCode, or sqlite3.ExtendedErrorCode +// to return specific error codes to SQLite. +// In particular, sqlite3.BUSY is needed to correctly implement lock methods. // // https://sqlite.org/c3ref/io_methods.html type File interface { @@ -193,8 +195,8 @@ type FileSharedMemory interface { // SharedMemory is a shared-memory WAL-index implementation. // Use [NewSharedMemory] to create a shared-memory. type SharedMemory interface { - shmMap(context.Context, api.Module, int32, int32, bool) (ptr_t, _ErrorCode) - shmLock(int32, int32, _ShmFlag) _ErrorCode + shmMap(context.Context, api.Module, int32, int32, bool) (ptr_t, error) + shmLock(int32, int32, _ShmFlag) error shmUnmap(bool) shmBarrier() io.Closer @@ -205,6 +207,10 @@ type blockingSharedMemory interface { shmEnableBlocking(block bool) } +// FileControl makes it easy to forward all fileControl methods, +// which we want to do for the checksum VFS. +// However, this is not a safe default, and other VFSes +// should explicitly wrap the methods they want to wrap. type fileControl interface { File fileControl(ctx context.Context, mod api.Module, op _FcntlOpcode, pArg ptr_t) _ErrorCode diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/const.go b/vendor/github.com/ncruces/go-sqlite3/vfs/const.go index 9ed67e385..ffb84dd76 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/const.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/const.go @@ -20,11 +20,11 @@ type ( type _ErrorCode uint32 func (e _ErrorCode) Error() string { - return util.ErrorCodeString(uint32(e)) + return util.ErrorCodeString(e) } const ( - _OK _ErrorCode = util.OK + _OK = util.OK _ERROR _ErrorCode = util.ERROR _PERM _ErrorCode = util.PERM _BUSY _ErrorCode = util.BUSY diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/file.go b/vendor/github.com/ncruces/go-sqlite3/vfs/file.go index bdebdf6aa..1ae6cdd9c 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/file.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/file.go @@ -40,7 +40,7 @@ func evalSymlinks(path string) (string, error) { func (vfsOS) Delete(path string, syncDir bool) error { err := os.Remove(path) if errors.Is(err, fs.ErrNotExist) { - return _IOERR_DELETE_NOENT + return sysError{err, _IOERR_DELETE_NOENT} } if err != nil { return err @@ -48,12 +48,12 @@ func (vfsOS) Delete(path string, syncDir bool) error { if isUnix && syncDir { f, err := os.Open(filepath.Dir(path)) if err != nil { - return _OK + return nil } defer f.Close() err = osSync(f, 0, SYNC_FULL) if err != nil { - return _IOERR_DIR_FSYNC + return sysError{err, _IOERR_DIR_FSYNC} } } return nil @@ -108,14 +108,14 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error } if err != nil { if name == nil { - return nil, flags, _IOERR_GETTEMPPATH + return nil, flags, sysError{err, _IOERR_GETTEMPPATH} } if errors.Is(err, syscall.EISDIR) { - return nil, flags, _CANTOPEN_ISDIR + return nil, flags, sysError{err, _CANTOPEN_ISDIR} } if isCreate && isJournl && errors.Is(err, fs.ErrPermission) && osAccess(name.String(), ACCESS_EXISTS) != nil { - return nil, flags, _READONLY_DIRECTORY + return nil, flags, sysError{err, _READONLY_DIRECTORY} } return nil, flags, err } @@ -123,7 +123,7 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error if modeof := name.URIParameter("modeof"); modeof != "" { if err = osSetMode(f, modeof); err != nil { f.Close() - return nil, flags, _IOERR_FSTAT + return nil, flags, sysError{err, _IOERR_FSTAT} } } if isUnix && flags&OPEN_DELETEONCLOSE != 0 { @@ -193,7 +193,7 @@ func (f *vfsFile) Sync(flags SyncFlag) error { defer d.Close() err = osSync(f.File, f.flags, flags) if err != nil { - return _IOERR_DIR_FSYNC + return sysError{err, _IOERR_DIR_FSYNC} } } return nil diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/filename.go b/vendor/github.com/ncruces/go-sqlite3/vfs/filename.go index be16b3dde..4d4fc4ae7 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/filename.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/filename.go @@ -120,7 +120,7 @@ func (n *Filename) URIParameter(key string) string { } // Parse the format from: - // https://github.com/sqlite/sqlite/blob/b74eb0/src/pager.c#L4797-L4840 + // https://github.com/sqlite/sqlite/blob/41fda52/src/pager.c#L4821-L4864 // This avoids having to alloc/free the key just to find a value. for { k := util.ReadString(n.mod, ptr, _MAX_NAME) @@ -160,7 +160,7 @@ func (n *Filename) URIParameters() url.Values { var params url.Values // Parse the format from: - // https://github.com/sqlite/sqlite/blob/b74eb0/src/pager.c#L4797-L4840 + // https://github.com/sqlite/sqlite/blob/41fda52/src/pager.c#L4821-L4864 // This is the only way to support multiple valued keys. for { k := util.ReadString(n.mod, ptr, _MAX_NAME) diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go b/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go index 253057aea..84c6e8da0 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go @@ -51,8 +51,8 @@ func (f *vfsFile) Lock(lock LockLevel) error { if f.lock != LOCK_NONE { panic(util.AssertErr()) } - if rc := osGetSharedLock(f.File); rc != _OK { - return rc + if err := osGetSharedLock(f.File); err != nil { + return err } f.lock = LOCK_SHARED return nil @@ -62,8 +62,8 @@ func (f *vfsFile) Lock(lock LockLevel) error { if f.lock != LOCK_SHARED { panic(util.AssertErr()) } - if rc := osGetReservedLock(f.File); rc != _OK { - return rc + if err := osGetReservedLock(f.File); err != nil { + return err } f.lock = LOCK_RESERVED return nil @@ -73,8 +73,8 @@ func (f *vfsFile) Lock(lock LockLevel) error { if f.lock <= LOCK_NONE || f.lock >= LOCK_EXCLUSIVE { panic(util.AssertErr()) } - if rc := osGetExclusiveLock(f.File, &f.lock); rc != _OK { - return rc + if err := osGetExclusiveLock(f.File, &f.lock); err != nil { + return err } f.lock = LOCK_EXCLUSIVE return nil @@ -101,14 +101,14 @@ func (f *vfsFile) Unlock(lock LockLevel) error { switch lock { case LOCK_SHARED: - rc := osDowngradeLock(f.File, f.lock) + err := osDowngradeLock(f.File, f.lock) f.lock = LOCK_SHARED - return rc + return err case LOCK_NONE: - rc := osReleaseLock(f.File, f.lock) + err := osReleaseLock(f.File, f.lock) f.lock = LOCK_NONE - return rc + return err default: panic(util.AssertErr()) diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go index 4542f8e7c..a70579d2c 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go @@ -8,13 +8,13 @@ import ( "golang.org/x/sys/unix" ) -func osGetSharedLock(file *os.File) _ErrorCode { +func osGetSharedLock(file *os.File) error { return osFlock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK) } -func osGetReservedLock(file *os.File) _ErrorCode { - rc := osFlock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK) - if rc == _BUSY { +func osGetReservedLock(file *os.File) error { + err := osFlock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK) + if err == _BUSY { // The documentation states that a lock is upgraded by // releasing the previous lock, then acquiring the new lock. // Going over the source code of various BSDs, though, @@ -26,19 +26,19 @@ func osGetReservedLock(file *os.File) _ErrorCode { // and invoke the busy handler if appropriate. return _BUSY_SNAPSHOT } - return rc + return err } -func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode { +func osGetExclusiveLock(file *os.File, state *LockLevel) error { if *state >= LOCK_RESERVED { - return _OK + return nil } return osGetReservedLock(file) } -func osDowngradeLock(file *os.File, _ LockLevel) _ErrorCode { - rc := osFlock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK) - if rc == _BUSY { +func osDowngradeLock(file *os.File, _ LockLevel) error { + err := osFlock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK) + if err == _BUSY { // The documentation states that a lock is downgraded by // releasing the previous lock then acquiring the new lock. // Going over the source code of various BSDs, though, @@ -46,44 +46,44 @@ func osDowngradeLock(file *os.File, _ LockLevel) _ErrorCode { // Return IOERR_RDLOCK, as BUSY would cause an assert to fail. return _IOERR_RDLOCK } - return _OK + return err } -func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode { +func osReleaseLock(file *os.File, _ LockLevel) error { for { err := unix.Flock(int(file.Fd()), unix.LOCK_UN) if err == nil { - return _OK + return nil } if err != unix.EINTR { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } } } -func osCheckReservedLock(file *os.File) (bool, _ErrorCode) { +func osCheckReservedLock(file *os.File) (bool, error) { // Test the RESERVED lock with fcntl(F_GETLK). // This only works on systems where fcntl and flock are compatible. // However, SQLite only calls this while holding a shared lock, // so the difference is immaterial. - lock, rc := osTestLock(file, _RESERVED_BYTE, 1) - return lock == unix.F_WRLCK, rc + lock, err := osTestLock(file, _RESERVED_BYTE, 1, _IOERR_CHECKRESERVEDLOCK) + return lock == unix.F_WRLCK, err } -func osFlock(file *os.File, how int, def _ErrorCode) _ErrorCode { +func osFlock(file *os.File, how int, def _ErrorCode) error { err := unix.Flock(int(file.Fd()), how) return osLockErrorCode(err, def) } -func osReadLock(file *os.File, start, len int64) _ErrorCode { +func osReadLock(file *os.File, start, len int64) error { return osLock(file, unix.F_RDLCK, start, len, _IOERR_RDLOCK) } -func osWriteLock(file *os.File, start, len int64) _ErrorCode { +func osWriteLock(file *os.File, start, len int64) error { return osLock(file, unix.F_WRLCK, start, len, _IOERR_LOCK) } -func osLock(file *os.File, typ int16, start, len int64, def _ErrorCode) _ErrorCode { +func osLock(file *os.File, typ int16, start, len int64, def _ErrorCode) error { err := unix.FcntlFlock(file.Fd(), unix.F_SETLK, &unix.Flock_t{ Type: typ, Start: start, @@ -92,7 +92,7 @@ func osLock(file *os.File, typ int16, start, len int64, def _ErrorCode) _ErrorCo return osLockErrorCode(err, def) } -func osUnlock(file *os.File, start, len int64) _ErrorCode { +func osUnlock(file *os.File, start, len int64) error { lock := unix.Flock_t{ Type: unix.F_UNLCK, Start: start, @@ -101,10 +101,10 @@ func osUnlock(file *os.File, start, len int64) _ErrorCode { for { err := unix.FcntlFlock(file.Fd(), unix.F_SETLK, &lock) if err == nil { - return _OK + return nil } if err != unix.EINTR { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } } } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go index 9bb8b559c..6748c2991 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go @@ -75,15 +75,15 @@ func osAllocate(file *os.File, size int64) error { return file.Truncate(size) } -func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode { +func osReadLock(file *os.File, start, len int64, timeout time.Duration) error { return osLock(file, unix.F_RDLCK, start, len, timeout, _IOERR_RDLOCK) } -func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode { +func osWriteLock(file *os.File, start, len int64, timeout time.Duration) error { return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK) } -func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) _ErrorCode { +func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) error { lock := &flocktimeout_t{fl: unix.Flock_t{ Type: typ, Start: start, @@ -103,7 +103,7 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d return osLockErrorCode(err, def) } -func osUnlock(file *os.File, start, len int64) _ErrorCode { +func osUnlock(file *os.File, start, len int64) error { lock := unix.Flock_t{ Type: unix.F_UNLCK, Start: start, @@ -112,10 +112,10 @@ func osUnlock(file *os.File, start, len int64) _ErrorCode { for { err := unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &lock) if err == nil { - return _OK + return nil } if err != unix.EINTR { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } } } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_dotlk.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_dotlk.go index 7a9c38897..b64e8ec05 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_dotlk.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_dotlk.go @@ -23,7 +23,7 @@ type vfsDotLocker struct { reserved *os.File // +checklocks:vfsDotLocksMtx } -func osGetSharedLock(file *os.File) _ErrorCode { +func osGetSharedLock(file *os.File) error { vfsDotLocksMtx.Lock() defer vfsDotLocksMtx.Unlock() @@ -34,7 +34,7 @@ func osGetSharedLock(file *os.File) _ErrorCode { if errors.Is(err, fs.ErrExist) { return _BUSY // Another process has the lock. } - return _IOERR_LOCK + return sysError{err, _IOERR_LOCK} } locker = &vfsDotLocker{} vfsDotLocks[name] = locker @@ -44,10 +44,10 @@ func osGetSharedLock(file *os.File) _ErrorCode { return _BUSY } locker.shared++ - return _OK + return nil } -func osGetReservedLock(file *os.File) _ErrorCode { +func osGetReservedLock(file *os.File) error { vfsDotLocksMtx.Lock() defer vfsDotLocksMtx.Unlock() @@ -61,10 +61,10 @@ func osGetReservedLock(file *os.File) _ErrorCode { return _BUSY } locker.reserved = file - return _OK + return nil } -func osGetExclusiveLock(file *os.File, _ *LockLevel) _ErrorCode { +func osGetExclusiveLock(file *os.File, _ *LockLevel) error { vfsDotLocksMtx.Lock() defer vfsDotLocksMtx.Unlock() @@ -81,10 +81,10 @@ func osGetExclusiveLock(file *os.File, _ *LockLevel) _ErrorCode { if locker.shared > 1 { return _BUSY } - return _OK + return nil } -func osDowngradeLock(file *os.File, _ LockLevel) _ErrorCode { +func osDowngradeLock(file *os.File, _ LockLevel) error { vfsDotLocksMtx.Lock() defer vfsDotLocksMtx.Unlock() @@ -100,10 +100,10 @@ func osDowngradeLock(file *os.File, _ LockLevel) _ErrorCode { if locker.pending == file { locker.pending = nil } - return _OK + return nil } -func osReleaseLock(file *os.File, state LockLevel) _ErrorCode { +func osReleaseLock(file *os.File, state LockLevel) error { vfsDotLocksMtx.Lock() defer vfsDotLocksMtx.Unlock() @@ -115,7 +115,7 @@ func osReleaseLock(file *os.File, state LockLevel) _ErrorCode { if locker.shared == 1 { if err := dotlk.Unlock(name + ".lock"); err != nil { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } delete(vfsDotLocks, name) } @@ -127,17 +127,14 @@ func osReleaseLock(file *os.File, state LockLevel) _ErrorCode { locker.pending = nil } locker.shared-- - return _OK + return nil } -func osCheckReservedLock(file *os.File) (bool, _ErrorCode) { +func osCheckReservedLock(file *os.File) (bool, error) { vfsDotLocksMtx.Lock() defer vfsDotLocksMtx.Unlock() name := file.Name() locker := vfsDotLocks[name] - if locker == nil { - return false, _OK - } - return locker.reserved != nil, _OK + return locker != nil && locker.reserved != nil, nil } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go index 893f1512c..1f7705ca0 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go @@ -44,15 +44,15 @@ func osAllocate(file *os.File, size int64) error { } -func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode { +func osReadLock(file *os.File, start, len int64, timeout time.Duration) error { return osLock(file, unix.F_RDLCK, start, len, timeout, _IOERR_RDLOCK) } -func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode { +func osWriteLock(file *os.File, start, len int64, timeout time.Duration) error { return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK) } -func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) _ErrorCode { +func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) error { lock := unix.Flock_t{ Type: typ, Start: start, @@ -68,7 +68,7 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d return osLockErrorCode(err, def) } -func osUnlock(file *os.File, start, len int64) _ErrorCode { +func osUnlock(file *os.File, start, len int64) error { lock := unix.Flock_t{ Type: unix.F_UNLCK, Start: start, @@ -77,10 +77,10 @@ func osUnlock(file *os.File, start, len int64) _ErrorCode { for { err := unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock) if err == nil { - return _OK + return nil } if err != unix.EINTR { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } } } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_ofd.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_ofd.go index d93050e8a..e917e12d4 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_ofd.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_ofd.go @@ -9,25 +9,25 @@ import ( "golang.org/x/sys/unix" ) -func osGetSharedLock(file *os.File) _ErrorCode { +func osGetSharedLock(file *os.File) error { // Test the PENDING lock before acquiring a new SHARED lock. - if lock, _ := osTestLock(file, _PENDING_BYTE, 1); lock == unix.F_WRLCK { + if lock, _ := osTestLock(file, _PENDING_BYTE, 1, _IOERR); lock == unix.F_WRLCK { return _BUSY } // Acquire the SHARED lock. return osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0) } -func osGetReservedLock(file *os.File) _ErrorCode { +func osGetReservedLock(file *os.File) error { // Acquire the RESERVED lock. return osWriteLock(file, _RESERVED_BYTE, 1, 0) } -func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode { +func osGetExclusiveLock(file *os.File, state *LockLevel) error { if *state == LOCK_RESERVED { // A PENDING lock is needed before acquiring an EXCLUSIVE lock. - if rc := osWriteLock(file, _PENDING_BYTE, 1, -1); rc != _OK { - return rc + if err := osWriteLock(file, _PENDING_BYTE, 1, -1); err != nil { + return err } *state = LOCK_PENDING } @@ -35,10 +35,10 @@ func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode { return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, time.Millisecond) } -func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode { +func osDowngradeLock(file *os.File, state LockLevel) error { if state >= LOCK_EXCLUSIVE { // Downgrade to a SHARED lock. - if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK { + if err := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); err != nil { // notest // this should never happen return _IOERR_RDLOCK } @@ -47,13 +47,13 @@ func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode { return osUnlock(file, _PENDING_BYTE, 2) } -func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode { +func osReleaseLock(file *os.File, _ LockLevel) error { // Release all locks. return osUnlock(file, 0, 0) } -func osCheckReservedLock(file *os.File) (bool, _ErrorCode) { +func osCheckReservedLock(file *os.File) (bool, error) { // Test the RESERVED lock. - lock, rc := osTestLock(file, _RESERVED_BYTE, 1) - return lock == unix.F_WRLCK, rc + lock, err := osTestLock(file, _RESERVED_BYTE, 1, _IOERR_CHECKRESERVEDLOCK) + return lock == unix.F_WRLCK, err } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix.go index ec312ccd3..69fdc8fbe 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix.go @@ -33,7 +33,7 @@ func osReadAt(file *os.File, p []byte, off int64) (int, error) { unix.ERANGE, unix.EIO, unix.ENXIO: - return n, _IOERR_CORRUPTFS + return n, sysError{err, _IOERR_CORRUPTFS} } } return n, err @@ -42,7 +42,7 @@ func osReadAt(file *os.File, p []byte, off int64) (int, error) { func osWriteAt(file *os.File, p []byte, off int64) (int, error) { n, err := file.WriteAt(p, off) if errno, ok := err.(unix.Errno); ok && errno == unix.ENOSPC { - return n, _FULL + return n, sysError{err, _FULL} } return n, err } @@ -59,7 +59,7 @@ func osSetMode(file *os.File, modeof string) error { return nil } -func osTestLock(file *os.File, start, len int64) (int16, _ErrorCode) { +func osTestLock(file *os.File, start, len int64, def _ErrorCode) (int16, error) { lock := unix.Flock_t{ Type: unix.F_WRLCK, Start: start, @@ -68,17 +68,17 @@ func osTestLock(file *os.File, start, len int64) (int16, _ErrorCode) { for { err := unix.FcntlFlock(file.Fd(), unix.F_GETLK, &lock) if err == nil { - return lock.Type, _OK + return lock.Type, nil } if err != unix.EINTR { - return 0, _IOERR_CHECKRESERVEDLOCK + return 0, sysError{err, def} } } } -func osLockErrorCode(err error, def _ErrorCode) _ErrorCode { +func osLockErrorCode(err error, def _ErrorCode) error { if err == nil { - return _OK + return nil } if errno, ok := err.(unix.Errno); ok { switch errno { @@ -92,12 +92,12 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode { unix.ETIMEDOUT: return _BUSY case unix.EPERM: - return _PERM + return sysError{err, _PERM} } // notest // usually EWOULDBLOCK == EAGAIN if errno == unix.EWOULDBLOCK && unix.EWOULDBLOCK != unix.EAGAIN { return _BUSY } } - return def + return sysError{err, def} } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go index 0a6693de5..eb843e39a 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go @@ -20,31 +20,31 @@ func osWriteAt(file *os.File, p []byte, off int64) (int, error) { case windows.ERROR_HANDLE_DISK_FULL, windows.ERROR_DISK_FULL: - return n, _FULL + return n, sysError{err, _FULL} } } return n, err } -func osGetSharedLock(file *os.File) _ErrorCode { +func osGetSharedLock(file *os.File) error { // Acquire the PENDING lock temporarily before acquiring a new SHARED lock. - rc := osReadLock(file, _PENDING_BYTE, 1, 0) - if rc == _OK { + err := osReadLock(file, _PENDING_BYTE, 1, 0) + if err == nil { // Acquire the SHARED lock. - rc = osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0) + err = osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0) // Release the PENDING lock. osUnlock(file, _PENDING_BYTE, 1) } - return rc + return err } -func osGetReservedLock(file *os.File) _ErrorCode { +func osGetReservedLock(file *os.File) error { // Acquire the RESERVED lock. return osWriteLock(file, _RESERVED_BYTE, 1, 0) } -func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode { +func osGetExclusiveLock(file *os.File, state *LockLevel) error { // A PENDING lock is needed before releasing the SHARED lock. if *state < LOCK_PENDING { // If we were RESERVED, we can block indefinitely. @@ -52,8 +52,8 @@ func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode { if *state == LOCK_RESERVED { timeout = -1 } - if rc := osWriteLock(file, _PENDING_BYTE, 1, timeout); rc != _OK { - return rc + if err := osWriteLock(file, _PENDING_BYTE, 1, timeout); err != nil { + return err } *state = LOCK_PENDING } @@ -63,25 +63,25 @@ func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode { // Acquire the EXCLUSIVE lock. // Can't wait here, because the file is not OVERLAPPED. - rc := osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, 0) + err := osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, 0) - if rc != _OK { + if err != nil { // Reacquire the SHARED lock. - if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK { + if err := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); err != nil { // notest // this should never happen return _IOERR_RDLOCK } } - return rc + return err } -func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode { +func osDowngradeLock(file *os.File, state LockLevel) error { if state >= LOCK_EXCLUSIVE { // Release the EXCLUSIVE lock while holding the PENDING lock. osUnlock(file, _SHARED_FIRST, _SHARED_SIZE) // Reacquire the SHARED lock. - if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK { + if err := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); err != nil { // notest // this should never happen return _IOERR_RDLOCK } @@ -94,10 +94,10 @@ func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode { if state >= LOCK_PENDING { osUnlock(file, _PENDING_BYTE, 1) } - return _OK + return nil } -func osReleaseLock(file *os.File, state LockLevel) _ErrorCode { +func osReleaseLock(file *os.File, state LockLevel) error { // Release all locks, PENDING must be last. if state >= LOCK_RESERVED { osUnlock(file, _RESERVED_BYTE, 1) @@ -108,31 +108,32 @@ func osReleaseLock(file *os.File, state LockLevel) _ErrorCode { if state >= LOCK_PENDING { osUnlock(file, _PENDING_BYTE, 1) } - return _OK + return nil } -func osCheckReservedLock(file *os.File) (bool, _ErrorCode) { +func osCheckReservedLock(file *os.File) (bool, error) { // Test the RESERVED lock. - rc := osLock(file, 0, _RESERVED_BYTE, 1, 0, _IOERR_CHECKRESERVEDLOCK) - if rc == _BUSY { - return true, _OK + err := osLock(file, 0, _RESERVED_BYTE, 1, 0, _IOERR_CHECKRESERVEDLOCK) + if err == _BUSY { + return true, nil } - if rc == _OK { + if err == nil { // Release the RESERVED lock. osUnlock(file, _RESERVED_BYTE, 1) + return false, nil } - return false, rc + return false, err } -func osReadLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode { +func osReadLock(file *os.File, start, len uint32, timeout time.Duration) error { return osLock(file, 0, start, len, timeout, _IOERR_RDLOCK) } -func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode { +func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) error { return osLock(file, windows.LOCKFILE_EXCLUSIVE_LOCK, start, len, timeout, _IOERR_LOCK) } -func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) _ErrorCode { +func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) error { var err error switch { default: @@ -143,16 +144,16 @@ func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def return osLockErrorCode(err, def) } -func osUnlock(file *os.File, start, len uint32) _ErrorCode { +func osUnlock(file *os.File, start, len uint32) error { err := windows.UnlockFileEx(windows.Handle(file.Fd()), 0, len, 0, &windows.Overlapped{Offset: start}) if err == windows.ERROR_NOT_LOCKED { - return _OK + return nil } if err != nil { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } - return _OK + return nil } func osLockEx(file *os.File, flags, start, len uint32) error { @@ -160,9 +161,9 @@ func osLockEx(file *os.File, flags, start, len uint32) error { 0, len, 0, &windows.Overlapped{Offset: start}) } -func osLockErrorCode(err error, def _ErrorCode) _ErrorCode { +func osLockErrorCode(err error, def _ErrorCode) error { if err == nil { - return _OK + return nil } if errno, ok := err.(windows.Errno); ok { // https://devblogs.microsoft.com/oldnewthing/20140905-00/?p=63 @@ -175,5 +176,5 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode { return _BUSY } } - return def + return sysError{err, def} } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go index be1495d99..ebf8418cc 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go @@ -3,6 +3,7 @@ package vfs import ( + "cmp" "context" "errors" "io" @@ -68,9 +69,9 @@ func (s *vfsShm) Close() error { panic(util.AssertErr()) } -func (s *vfsShm) shmOpen() (rc _ErrorCode) { +func (s *vfsShm) shmOpen() (err error) { if s.vfsShmParent != nil { - return _OK + return nil } vfsShmListMtx.Lock() @@ -80,7 +81,7 @@ func (s *vfsShm) shmOpen() (rc _ErrorCode) { // Closing it would release all POSIX locks on it. fi, err := os.Stat(s.path) if err != nil && !errors.Is(err, fs.ErrNotExist) { - return _IOERR_FSTAT + return sysError{err, _IOERR_FSTAT} } // Find a shared file, increase the reference count. @@ -88,7 +89,7 @@ func (s *vfsShm) shmOpen() (rc _ErrorCode) { if g != nil && os.SameFile(fi, g.info) { s.vfsShmParent = g g.refs++ - return _OK + return nil } } @@ -96,34 +97,34 @@ func (s *vfsShm) shmOpen() (rc _ErrorCode) { f, err := os.OpenFile(s.path, os.O_RDWR|os.O_CREATE|_O_NOFOLLOW, 0666) if err != nil { - return _CANTOPEN + return sysError{err, _CANTOPEN} } defer func() { - if rc != _OK { + if err != nil { f.Close() } }() // Dead man's switch. - if lock, rc := osTestLock(f, _SHM_DMS, 1); rc != _OK { - return _IOERR_LOCK + if lock, err := osTestLock(f, _SHM_DMS, 1, _IOERR_LOCK); err != nil { + return err } else if lock == unix.F_WRLCK { return _BUSY } else if lock == unix.F_UNLCK { - if rc := osWriteLock(f, _SHM_DMS, 1); rc != _OK { - return rc + if err := osWriteLock(f, _SHM_DMS, 1); err != nil { + return err } if err := f.Truncate(0); err != nil { - return _IOERR_SHMOPEN + return sysError{err, _IOERR_SHMOPEN} } } - if rc := osReadLock(f, _SHM_DMS, 1); rc != _OK { - return rc + if err := osReadLock(f, _SHM_DMS, 1); err != nil { + return err } fi, err = f.Stat() if err != nil { - return _IOERR_FSTAT + return sysError{err, _IOERR_FSTAT} } // Add the new shared file. @@ -134,53 +135,57 @@ func (s *vfsShm) shmOpen() (rc _ErrorCode) { for i, g := range vfsShmList { if g == nil { vfsShmList[i] = s.vfsShmParent - return _OK + return nil } } vfsShmList = append(vfsShmList, s.vfsShmParent) - return _OK + return nil } -func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (ptr_t, _ErrorCode) { +func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (ptr_t, error) { // Ensure size is a multiple of the OS page size. if int(size)&(unix.Getpagesize()-1) != 0 { return 0, _IOERR_SHMMAP } - if rc := s.shmOpen(); rc != _OK { - return 0, rc + if err := s.shmOpen(); err != nil { + return 0, err } // Check if file is big enough. o, err := s.Seek(0, io.SeekEnd) if err != nil { - return 0, _IOERR_SHMSIZE + return 0, sysError{err, _IOERR_SHMSIZE} } if n := (int64(id) + 1) * int64(size); n > o { if !extend { - return 0, _OK + return 0, nil } - if osAllocate(s.File, n) != nil { - return 0, _IOERR_SHMSIZE + if err := osAllocate(s.File, n); err != nil { + return 0, sysError{err, _IOERR_SHMSIZE} } } r, err := util.MapRegion(ctx, mod, s.File, int64(id)*int64(size), size, false) if err != nil { - return 0, _IOERR_SHMMAP + return 0, err } s.regions = append(s.regions, r) - return r.Ptr, _OK + return r.Ptr, nil } -func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) _ErrorCode { +func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) error { + if s.vfsShmParent == nil { + return _IOERR_SHMLOCK + } + s.Lock() defer s.Unlock() // Check if we can obtain/release locks locally. - rc := s.shmMemLock(offset, n, flags) - if rc != _OK { - return rc + err := s.shmMemLock(offset, n, flags) + if err != nil { + return err } // Obtain/release the appropriate file locks. @@ -192,36 +197,38 @@ func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) _ErrorCode { for i := begin; i < end; i++ { if s.vfsShmParent.lock[i] != 0 { if i > begin { - rc |= osUnlock(s.File, _SHM_BASE+int64(begin), int64(i-begin)) + err = cmp.Or(err, + osUnlock(s.File, _SHM_BASE+int64(begin), int64(i-begin))) } begin = i + 1 } } if end > begin { - rc |= osUnlock(s.File, _SHM_BASE+int64(begin), int64(end-begin)) + err = cmp.Or(err, + osUnlock(s.File, _SHM_BASE+int64(begin), int64(end-begin))) } - return rc + return err case flags&_SHM_SHARED != 0: // Acquiring a new shared lock on the file is only necessary // if there was a new shared lock in the range. for i := offset; i < offset+n; i++ { if s.vfsShmParent.lock[i] == 1 { - rc = osReadLock(s.File, _SHM_BASE+int64(offset), int64(n)) + err = osReadLock(s.File, _SHM_BASE+int64(offset), int64(n)) break } } case flags&_SHM_EXCLUSIVE != 0: // Acquiring an exclusive lock on the file is always necessary. - rc = osWriteLock(s.File, _SHM_BASE+int64(offset), int64(n)) + err = osWriteLock(s.File, _SHM_BASE+int64(offset), int64(n)) default: panic(util.AssertErr()) } - // Release the local locks we had acquired. - if rc != _OK { + if err != nil { + // Release the local locks we had acquired. s.shmMemLock(offset, n, flags^(_SHM_UNLOCK|_SHM_LOCK)) } - return rc + return err } func (s *vfsShm) shmUnmap(delete bool) { diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_copy.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_copy.go index db8ddb4b8..8e40aafb7 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_copy.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_copy.go @@ -31,8 +31,8 @@ const ( // // https://sqlite.org/walformat.html#the_wal_index_file_format -func (s *vfsShm) shmAcquire(ptr *_ErrorCode) { - if ptr != nil && *ptr != _OK { +func (s *vfsShm) shmAcquire(errp *error) { + if errp != nil && *errp != nil { return } if len(s.ptrs) == 0 || shmEqual(s.shadow[0][:], s.shared[0][:]) { diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_dotlk.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_dotlk.go index cb697a9c8..8f2bc6ce1 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_dotlk.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_dotlk.go @@ -59,16 +59,16 @@ func (s *vfsShm) Close() error { } if err := dotlk.Unlock(s.path); err != nil { - return _IOERR_UNLOCK + return sysError{err, _IOERR_UNLOCK} } delete(vfsShmList, s.path) s.vfsShmParent = nil return nil } -func (s *vfsShm) shmOpen() _ErrorCode { +func (s *vfsShm) shmOpen() error { if s.vfsShmParent != nil { - return _OK + return nil } vfsShmListMtx.Lock() @@ -78,7 +78,7 @@ func (s *vfsShm) shmOpen() _ErrorCode { if g, ok := vfsShmList[s.path]; ok { s.vfsShmParent = g g.refs++ - return _OK + return nil } // Dead man's switch. @@ -87,16 +87,16 @@ func (s *vfsShm) shmOpen() _ErrorCode { return _BUSY } if err != nil { - return _IOERR_LOCK + return sysError{err, _IOERR_LOCK} } // Add the new shared buffer. s.vfsShmParent = &vfsShmParent{} vfsShmList[s.path] = s.vfsShmParent - return _OK + return nil } -func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (ptr_t, _ErrorCode) { +func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (ptr_t, error) { if size != _WALINDEX_PGSZ { return 0, _IOERR_SHMMAP } @@ -105,8 +105,8 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext s.free = mod.ExportedFunction("sqlite3_free") s.alloc = mod.ExportedFunction("sqlite3_malloc64") } - if rc := s.shmOpen(); rc != _OK { - return 0, rc + if err := s.shmOpen(); err != nil { + return 0, err } s.Lock() @@ -116,7 +116,7 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext // Extend shared memory. if int(id) >= len(s.shared) { if !extend { - return 0, _OK + return 0, nil } s.shared = append(s.shared, make([][_WALINDEX_PGSZ]byte, int(id)-len(s.shared)+1)...) } @@ -140,16 +140,20 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext } s.shadow[0][4] = 1 - return s.ptrs[id], _OK + return s.ptrs[id], nil } -func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (rc _ErrorCode) { +func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (err error) { + if s.vfsShmParent == nil { + return _IOERR_SHMLOCK + } + s.Lock() defer s.Unlock() switch { case flags&_SHM_LOCK != 0: - defer s.shmAcquire(&rc) + defer s.shmAcquire(&err) case flags&_SHM_EXCLUSIVE != 0: s.shmRelease() } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_memlk.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_memlk.go index 5c8071ebe..d23c26c3b 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_memlk.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_memlk.go @@ -5,7 +5,7 @@ package vfs import "github.com/ncruces/go-sqlite3/internal/util" // +checklocks:s.Mutex -func (s *vfsShm) shmMemLock(offset, n int32, flags _ShmFlag) _ErrorCode { +func (s *vfsShm) shmMemLock(offset, n int32, flags _ShmFlag) error { switch { case flags&_SHM_UNLOCK != 0: for i := offset; i < offset+n; i++ { @@ -48,6 +48,5 @@ func (s *vfsShm) shmMemLock(offset, n int32, flags _ShmFlag) _ErrorCode { default: panic(util.AssertErr()) } - - return _OK + return nil } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_ofd.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_ofd.go index b0f50fcb5..de31e59d6 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_ofd.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_ofd.go @@ -27,7 +27,10 @@ type vfsShm struct { var _ blockingSharedMemory = &vfsShm{} -func (s *vfsShm) shmOpen() _ErrorCode { +func (s *vfsShm) shmOpen() error { + if s.fileLock { + return nil + } if s.File == nil { f, err := os.OpenFile(s.path, os.O_RDWR|os.O_CREATE|_O_NOFOLLOW, 0666) @@ -37,17 +40,15 @@ func (s *vfsShm) shmOpen() _ErrorCode { s.readOnly = true } if err != nil { - return _CANTOPEN + return sysError{err, _CANTOPEN} } + s.fileLock = false s.File = f } - if s.fileLock { - return _OK - } // Dead man's switch. - if lock, rc := osTestLock(s.File, _SHM_DMS, 1); rc != _OK { - return _IOERR_LOCK + if lock, err := osTestLock(s.File, _SHM_DMS, 1, _IOERR_LOCK); err != nil { + return err } else if lock == unix.F_WRLCK { return _BUSY } else if lock == unix.F_UNLCK { @@ -61,54 +62,57 @@ func (s *vfsShm) shmOpen() _ErrorCode { // but only downgrade it to a shared lock. // So no point in blocking here. // The call below to obtain the shared DMS lock may use a blocking lock. - if rc := osWriteLock(s.File, _SHM_DMS, 1, 0); rc != _OK { - return rc + if err := osWriteLock(s.File, _SHM_DMS, 1, 0); err != nil { + return err } if err := s.Truncate(0); err != nil { - return _IOERR_SHMOPEN + return sysError{err, _IOERR_SHMOPEN} } } - rc := osReadLock(s.File, _SHM_DMS, 1, time.Millisecond) - s.fileLock = rc == _OK - return rc + err := osReadLock(s.File, _SHM_DMS, 1, time.Millisecond) + s.fileLock = err == nil + return err } -func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (ptr_t, _ErrorCode) { +func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (ptr_t, error) { // Ensure size is a multiple of the OS page size. if int(size)&(unix.Getpagesize()-1) != 0 { return 0, _IOERR_SHMMAP } - if rc := s.shmOpen(); rc != _OK { - return 0, rc + if err := s.shmOpen(); err != nil { + return 0, err } // Check if file is big enough. o, err := s.Seek(0, io.SeekEnd) if err != nil { - return 0, _IOERR_SHMSIZE + return 0, sysError{err, _IOERR_SHMSIZE} } if n := (int64(id) + 1) * int64(size); n > o { if !extend { - return 0, _OK + return 0, nil } - if s.readOnly || osAllocate(s.File, n) != nil { + if s.readOnly { return 0, _IOERR_SHMSIZE } + if err := osAllocate(s.File, n); err != nil { + return 0, sysError{err, _IOERR_SHMSIZE} + } } r, err := util.MapRegion(ctx, mod, s.File, int64(id)*int64(size), size, s.readOnly) if err != nil { - return 0, _IOERR_SHMMAP + return 0, err } s.regions = append(s.regions, r) if s.readOnly { return r.Ptr, _READONLY } - return r.Ptr, _OK + return r.Ptr, nil } -func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) _ErrorCode { +func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) error { // Argument check. switch { case n <= 0: @@ -129,6 +133,10 @@ func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) _ErrorCode { panic(util.AssertErr()) } + if s.File == nil { + return _IOERR_SHMLOCK + } + var timeout time.Duration if s.blocking { timeout = time.Millisecond @@ -163,6 +171,7 @@ func (s *vfsShm) shmUnmap(delete bool) { } s.Close() s.File = nil + s.fileLock = false } func (s *vfsShm) shmBarrier() { diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_windows.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_windows.go index 0be523ad6..ad3e153ae 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_windows.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_windows.go @@ -40,32 +40,33 @@ func (s *vfsShm) Close() error { return s.File.Close() } -func (s *vfsShm) shmOpen() _ErrorCode { +func (s *vfsShm) shmOpen() error { + if s.fileLock { + return nil + } if s.File == nil { f, err := os.OpenFile(s.path, os.O_RDWR|os.O_CREATE, 0666) if err != nil { - return _CANTOPEN + return sysError{err, _CANTOPEN} } + s.fileLock = false s.File = f } - if s.fileLock { - return _OK - } // Dead man's switch. - if rc := osWriteLock(s.File, _SHM_DMS, 1, 0); rc == _OK { + if osWriteLock(s.File, _SHM_DMS, 1, 0) == nil { err := s.Truncate(0) osUnlock(s.File, _SHM_DMS, 1) if err != nil { - return _IOERR_SHMOPEN + return sysError{err, _IOERR_SHMOPEN} } } - rc := osReadLock(s.File, _SHM_DMS, 1, 0) - s.fileLock = rc == _OK - return rc + err := osReadLock(s.File, _SHM_DMS, 1, 0) + s.fileLock = err == nil + return err } -func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (_ ptr_t, rc _ErrorCode) { +func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (_ ptr_t, err error) { // Ensure size is a multiple of the OS page size. if size != _WALINDEX_PGSZ || (windows.Getpagesize()-1)&_WALINDEX_PGSZ != 0 { return 0, _IOERR_SHMMAP @@ -75,23 +76,23 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext s.free = mod.ExportedFunction("sqlite3_free") s.alloc = mod.ExportedFunction("sqlite3_malloc64") } - if rc := s.shmOpen(); rc != _OK { - return 0, rc + if err := s.shmOpen(); err != nil { + return 0, err } - defer s.shmAcquire(&rc) + defer s.shmAcquire(&err) // Check if file is big enough. o, err := s.Seek(0, io.SeekEnd) if err != nil { - return 0, _IOERR_SHMSIZE + return 0, sysError{err, _IOERR_SHMSIZE} } if n := (int64(id) + 1) * int64(size); n > o { if !extend { - return 0, _OK + return 0, nil } - if osAllocate(s.File, n) != nil { - return 0, _IOERR_SHMSIZE + if err := osAllocate(s.File, n); err != nil { + return 0, sysError{err, _IOERR_SHMSIZE} } } @@ -99,7 +100,7 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext for int(id) >= len(s.shared) { r, err := util.MapRegion(ctx, mod, s.File, int64(id)*int64(size), size) if err != nil { - return 0, _IOERR_SHMMAP + return 0, err } s.regions = append(s.regions, r) s.shared = append(s.shared, r.Data) @@ -124,13 +125,17 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext } s.shadow[0][4] = 1 - return s.ptrs[id], _OK + return s.ptrs[id], nil } -func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (rc _ErrorCode) { +func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (err error) { + if s.File == nil { + return _IOERR_SHMLOCK + } + switch { case flags&_SHM_LOCK != 0: - defer s.shmAcquire(&rc) + defer s.shmAcquire(&err) case flags&_SHM_EXCLUSIVE != 0: s.shmRelease() } @@ -168,6 +173,7 @@ func (s *vfsShm) shmUnmap(delete bool) { // Close the file. s.Close() s.File = nil + s.fileLock = false if delete { os.Remove(s.path) } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go b/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go index aef81c3f2..569346fb2 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go @@ -102,7 +102,7 @@ func vfsFullPathname(ctx context.Context, mod api.Module, pVfs, zRelative ptr_t, } util.WriteString(mod, zFull, path) - return vfsErrorCode(err, _CANTOPEN_FULLPATH) + return vfsErrorCode(ctx, err, _CANTOPEN_FULLPATH) } func vfsDelete(ctx context.Context, mod api.Module, pVfs, zPath ptr_t, syncDir int32) _ErrorCode { @@ -110,7 +110,7 @@ func vfsDelete(ctx context.Context, mod api.Module, pVfs, zPath ptr_t, syncDir i path := util.ReadString(mod, zPath, _MAX_PATHNAME) err := vfs.Delete(path, syncDir != 0) - return vfsErrorCode(err, _IOERR_DELETE) + return vfsErrorCode(ctx, err, _IOERR_DELETE) } func vfsAccess(ctx context.Context, mod api.Module, pVfs, zPath ptr_t, flags AccessFlag, pResOut ptr_t) _ErrorCode { @@ -119,7 +119,7 @@ func vfsAccess(ctx context.Context, mod api.Module, pVfs, zPath ptr_t, flags Acc ok, err := vfs.Access(path, flags) util.WriteBool(mod, pResOut, ok) - return vfsErrorCode(err, _IOERR_ACCESS) + return vfsErrorCode(ctx, err, _IOERR_ACCESS) } func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile ptr_t, flags OpenFlag, pOutFlags, pOutVFS ptr_t) _ErrorCode { @@ -134,7 +134,7 @@ func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile ptr_t, flag file, flags, err = vfs.Open(name.String(), flags) } if err != nil { - return vfsErrorCode(err, _CANTOPEN) + return vfsErrorCode(ctx, err, _CANTOPEN) } if file, ok := file.(FilePowersafeOverwrite); ok { @@ -155,7 +155,7 @@ func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile ptr_t, flag func vfsClose(ctx context.Context, mod api.Module, pFile ptr_t) _ErrorCode { err := vfsFileClose(ctx, mod, pFile) - return vfsErrorCode(err, _IOERR_CLOSE) + return vfsErrorCode(ctx, err, _IOERR_CLOSE) } func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf ptr_t, iAmt int32, iOfst int64) _ErrorCode { @@ -167,7 +167,7 @@ func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf ptr_t, iAmt int32, return _OK } if err != io.EOF { - return vfsErrorCode(err, _IOERR_READ) + return vfsErrorCode(ctx, err, _IOERR_READ) } clear(buf[n:]) return _IOERR_SHORT_READ @@ -178,45 +178,45 @@ func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf ptr_t, iAmt int32 buf := util.View(mod, zBuf, int64(iAmt)) _, err := file.WriteAt(buf, iOfst) - return vfsErrorCode(err, _IOERR_WRITE) + return vfsErrorCode(ctx, err, _IOERR_WRITE) } func vfsTruncate(ctx context.Context, mod api.Module, pFile ptr_t, nByte int64) _ErrorCode { file := vfsFileGet(ctx, mod, pFile).(File) err := file.Truncate(nByte) - return vfsErrorCode(err, _IOERR_TRUNCATE) + return vfsErrorCode(ctx, err, _IOERR_TRUNCATE) } func vfsSync(ctx context.Context, mod api.Module, pFile ptr_t, flags SyncFlag) _ErrorCode { file := vfsFileGet(ctx, mod, pFile).(File) err := file.Sync(flags) - return vfsErrorCode(err, _IOERR_FSYNC) + return vfsErrorCode(ctx, err, _IOERR_FSYNC) } func vfsFileSize(ctx context.Context, mod api.Module, pFile, pSize ptr_t) _ErrorCode { file := vfsFileGet(ctx, mod, pFile).(File) size, err := file.Size() util.Write64(mod, pSize, size) - return vfsErrorCode(err, _IOERR_SEEK) + return vfsErrorCode(ctx, err, _IOERR_SEEK) } func vfsLock(ctx context.Context, mod api.Module, pFile ptr_t, eLock LockLevel) _ErrorCode { file := vfsFileGet(ctx, mod, pFile).(File) err := file.Lock(eLock) - return vfsErrorCode(err, _IOERR_LOCK) + return vfsErrorCode(ctx, err, _IOERR_LOCK) } func vfsUnlock(ctx context.Context, mod api.Module, pFile ptr_t, eLock LockLevel) _ErrorCode { file := vfsFileGet(ctx, mod, pFile).(File) err := file.Unlock(eLock) - return vfsErrorCode(err, _IOERR_UNLOCK) + return vfsErrorCode(ctx, err, _IOERR_UNLOCK) } func vfsCheckReservedLock(ctx context.Context, mod api.Module, pFile, pResOut ptr_t) _ErrorCode { file := vfsFileGet(ctx, mod, pFile).(File) locked, err := file.CheckReservedLock() util.WriteBool(mod, pResOut, locked) - return vfsErrorCode(err, _IOERR_CHECKRESERVEDLOCK) + return vfsErrorCode(ctx, err, _IOERR_CHECKRESERVEDLOCK) } func vfsFileControl(ctx context.Context, mod api.Module, pFile ptr_t, op _FcntlOpcode, pArg ptr_t) _ErrorCode { @@ -268,20 +268,20 @@ func vfsFileControlImpl(ctx context.Context, mod api.Module, file File, op _Fcnt if file, ok := file.(FileSizeHint); ok { size := util.Read64[int64](mod, pArg) err := file.SizeHint(size) - return vfsErrorCode(err, _IOERR_TRUNCATE) + return vfsErrorCode(ctx, err, _IOERR_TRUNCATE) } case _FCNTL_HAS_MOVED: if file, ok := file.(FileHasMoved); ok { moved, err := file.HasMoved() util.WriteBool(mod, pArg, moved) - return vfsErrorCode(err, _IOERR_FSTAT) + return vfsErrorCode(ctx, err, _IOERR_FSTAT) } case _FCNTL_OVERWRITE: if file, ok := file.(FileOverwrite); ok { err := file.Overwrite() - return vfsErrorCode(err, _IOERR) + return vfsErrorCode(ctx, err, _IOERR) } case _FCNTL_SYNC: @@ -291,29 +291,29 @@ func vfsFileControlImpl(ctx context.Context, mod api.Module, file File, op _Fcnt name = util.ReadString(mod, pArg, _MAX_PATHNAME) } err := file.SyncSuper(name) - return vfsErrorCode(err, _IOERR) + return vfsErrorCode(ctx, err, _IOERR) } case _FCNTL_COMMIT_PHASETWO: if file, ok := file.(FileCommitPhaseTwo); ok { err := file.CommitPhaseTwo() - return vfsErrorCode(err, _IOERR) + return vfsErrorCode(ctx, err, _IOERR) } case _FCNTL_BEGIN_ATOMIC_WRITE: if file, ok := file.(FileBatchAtomicWrite); ok { err := file.BeginAtomicWrite() - return vfsErrorCode(err, _IOERR_BEGIN_ATOMIC) + return vfsErrorCode(ctx, err, _IOERR_BEGIN_ATOMIC) } case _FCNTL_COMMIT_ATOMIC_WRITE: if file, ok := file.(FileBatchAtomicWrite); ok { err := file.CommitAtomicWrite() - return vfsErrorCode(err, _IOERR_COMMIT_ATOMIC) + return vfsErrorCode(ctx, err, _IOERR_COMMIT_ATOMIC) } case _FCNTL_ROLLBACK_ATOMIC_WRITE: if file, ok := file.(FileBatchAtomicWrite); ok { err := file.RollbackAtomicWrite() - return vfsErrorCode(err, _IOERR_ROLLBACK_ATOMIC) + return vfsErrorCode(ctx, err, _IOERR_ROLLBACK_ATOMIC) } case _FCNTL_CKPT_START: @@ -338,7 +338,7 @@ func vfsFileControlImpl(ctx context.Context, mod api.Module, file File, op _Fcnt out, err := file.Pragma(strings.ToLower(name), value) - ret := vfsErrorCode(err, _ERROR) + ret := vfsErrorCode(ctx, err, _ERROR) if ret == _ERROR { out = err.Error() } @@ -407,14 +407,15 @@ func vfsShmBarrier(ctx context.Context, mod api.Module, pFile ptr_t) { func vfsShmMap(ctx context.Context, mod api.Module, pFile ptr_t, iRegion, szRegion, bExtend int32, pp ptr_t) _ErrorCode { shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory() - p, rc := shm.shmMap(ctx, mod, iRegion, szRegion, bExtend != 0) + p, err := shm.shmMap(ctx, mod, iRegion, szRegion, bExtend != 0) util.Write32(mod, pp, p) - return rc + return vfsErrorCode(ctx, err, _IOERR_SHMMAP) } func vfsShmLock(ctx context.Context, mod api.Module, pFile ptr_t, offset, n int32, flags _ShmFlag) _ErrorCode { shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory() - return shm.shmLock(offset, n, flags) + err := shm.shmLock(offset, n, flags) + return vfsErrorCode(ctx, err, _IOERR_SHMLOCK) } func vfsShmUnmap(ctx context.Context, mod api.Module, pFile ptr_t, bDelete int32) _ErrorCode { @@ -454,13 +455,38 @@ func vfsFileClose(ctx context.Context, mod api.Module, pFile ptr_t) error { return util.DelHandle(ctx, id) } -func vfsErrorCode(err error, def _ErrorCode) _ErrorCode { - if err == nil { - return _OK +func vfsErrorCode(ctx context.Context, err error, code _ErrorCode) _ErrorCode { + var sys error + + switch err := err.(type) { + case nil: + code = _OK + case _ErrorCode: + code = err + case sysError: + code = err.code + sys = err.error + default: + switch v := reflect.ValueOf(err); v.Kind() { + case reflect.Uint8, reflect.Uint16: + code = _ErrorCode(v.Uint()) + } } - switch v := reflect.ValueOf(err); v.Kind() { - case reflect.Uint8, reflect.Uint16, reflect.Uint32: - return _ErrorCode(v.Uint()) + + util.SetSystemError(ctx, sys) + return code +} + +// SystemError tags an error with a given +// sqlite3.ErrorCode or sqlite3.ExtendedErrorCode. +func SystemError[T interface{ ~uint8 | ~uint16 }](err error, code T) error { + if err == nil { + return nil } - return def + return sysError{error: err, code: _ErrorCode(code)} +} + +type sysError struct { + error + code _ErrorCode } diff --git a/vendor/github.com/ncruces/go-sqlite3/vtab.go b/vendor/github.com/ncruces/go-sqlite3/vtab.go index 16ff2806b..e1f3ad71a 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vtab.go +++ b/vendor/github.com/ncruces/go-sqlite3/vtab.go @@ -445,7 +445,8 @@ const ( type IndexScanFlag uint32 const ( - INDEX_SCAN_UNIQUE IndexScanFlag = 1 + INDEX_SCAN_UNIQUE IndexScanFlag = 0x00000001 + INDEX_SCAN_HEX IndexScanFlag = 0x00000002 ) func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _ ptr_t, _ int32, _, _, _ ptr_t) res_t { @@ -465,19 +466,19 @@ func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, vtabPutHandle(ctx, mod, ppVTab, val[0].Interface()) } - return vtabError(ctx, mod, pzErr, _PTR_ERROR, err) + return vtabError(ctx, mod, pzErr, _PTR_ERROR, err, ERROR) } } func vtabDisconnectCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t { err := vtabDelHandle(ctx, mod, pVTab) - return vtabError(ctx, mod, 0, _PTR_ERROR, err) + return vtabError(ctx, mod, 0, _PTR_ERROR, err, ERROR) } func vtabDestroyCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabDestroyer) err := errors.Join(vtab.Destroy(), vtabDelHandle(ctx, mod, pVTab)) - return vtabError(ctx, mod, 0, _PTR_ERROR, err) + return vtabError(ctx, mod, 0, _PTR_ERROR, err, ERROR) } func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo ptr_t) res_t { @@ -490,7 +491,7 @@ func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo err := vtab.BestIndex(&info) info.save() - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, pArg, pRowID ptr_t) res_t { @@ -504,13 +505,13 @@ func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg i util.Write64(mod, pRowID, rowID) } - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabRenameCallback(ctx context.Context, mod api.Module, pVTab, zNew ptr_t) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabRenamer) err := vtab.Rename(util.ReadString(mod, zNew, _MAX_NAME)) - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabFindFuncCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, zName, pxFunc ptr_t) int32 { @@ -534,51 +535,49 @@ func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema, err := vtab.Integrity(schema, table, int(mFlags)) // xIntegrity should return OK - even if it finds problems in the content of the virtual table. // https://sqlite.org/vtab.html#xintegrity - vtabError(ctx, mod, pzErr, _PTR_ERROR, err) - _, code := errorCode(err, _OK) - return code + return vtabError(ctx, mod, pzErr, _PTR_ERROR, err, _OK) } func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn) err := vtab.Begin() - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn) err := vtab.Sync() - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn) err := vtab.Commit() - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn) err := vtab.Rollback() - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabSavepointCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer) err := vtab.Savepoint(int(id)) - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabReleaseCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer) err := vtab.Release(int(id)) - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func vtabRollbackToCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t { vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer) err := vtab.RollbackTo(int(id)) - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur ptr_t) res_t { @@ -589,12 +588,12 @@ func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur ptr_t) vtabPutHandle(ctx, mod, ppCur, cursor) } - return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err) + return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err, ERROR) } func cursorCloseCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t { err := vtabDelHandle(ctx, mod, pCur) - return vtabError(ctx, mod, 0, _VTAB_ERROR, err) + return vtabError(ctx, mod, 0, _PTR_ERROR, err, ERROR) } func cursorFilterCallback(ctx context.Context, mod api.Module, pCur ptr_t, idxNum int32, idxStr ptr_t, nArg int32, pArg ptr_t) res_t { @@ -609,7 +608,7 @@ func cursorFilterCallback(ctx context.Context, mod api.Module, pCur ptr_t, idxNu cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor) err := cursor.Filter(int(idxNum), idxName, *args...) - return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err) + return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err, ERROR) } func cursorEOFCallback(ctx context.Context, mod api.Module, pCur ptr_t) int32 { @@ -623,14 +622,14 @@ func cursorEOFCallback(ctx context.Context, mod api.Module, pCur ptr_t) int32 { func cursorNextCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t { cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor) err := cursor.Next() - return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err) + return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err, ERROR) } func cursorColumnCallback(ctx context.Context, mod api.Module, pCur, pCtx ptr_t, n int32) res_t { cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor) db := ctx.Value(connKey{}).(*Conn) err := cursor.Column(Context{db, pCtx}, int(n)) - return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err) + return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err, ERROR) } func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID ptr_t) res_t { @@ -641,7 +640,7 @@ func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID ptr_t util.Write64(mod, pRowID, rowID) } - return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err) + return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err, ERROR) } const ( @@ -650,10 +649,10 @@ const ( _CURSOR_ERROR ) -func vtabError(ctx context.Context, mod api.Module, ptr ptr_t, kind uint32, err error) res_t { +func vtabError(ctx context.Context, mod api.Module, ptr ptr_t, kind uint32, err error, def ErrorCode) res_t { const zErrMsgOffset = 8 - msg, code := errorCode(err, ERROR) - if msg != "" && ptr != 0 { + msg, code := errorCode(err, def) + if ptr != 0 && msg != "" { switch kind { case _VTAB_ERROR: ptr = ptr + zErrMsgOffset // zErrMsg diff --git a/vendor/modules.txt b/vendor/modules.txt index 215a63879..5563b2445 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -274,7 +274,7 @@ codeberg.org/gruf/go-maps # codeberg.org/gruf/go-mempool v0.0.0-20251003110531-b54adae66253 ## explicit; go 1.24.0 codeberg.org/gruf/go-mempool -# codeberg.org/gruf/go-mmap v0.0.0-20251105140602-5f31e9314dbf +# codeberg.org/gruf/go-mmap v0.0.0-20251105200114-34f58283863a ## explicit; go 1.20 codeberg.org/gruf/go-mmap # codeberg.org/gruf/go-mutexes v1.5.8 @@ -670,6 +670,9 @@ github.com/klauspost/compress/s2 # github.com/klauspost/cpuid/v2 v2.3.0 ## explicit; go 1.22 github.com/klauspost/cpuid/v2 +# github.com/klauspost/crc32 v1.3.0 +## explicit; go 1.23.0 +github.com/klauspost/crc32 # github.com/kr/pretty v0.3.1 ## explicit; go 1.12 github.com/kr/pretty @@ -695,23 +698,21 @@ github.com/microcosm-cc/bluemonday/css # github.com/miekg/dns v1.1.68 ## explicit; go 1.23.0 github.com/miekg/dns -# github.com/minio/crc64nvme v1.0.2 +# github.com/minio/crc64nvme v1.1.0 ## explicit; go 1.22 github.com/minio/crc64nvme # github.com/minio/md5-simd v1.1.2 ## explicit; go 1.14 github.com/minio/md5-simd -# github.com/minio/minio-go/v7 v7.0.95 +# github.com/minio/minio-go/v7 v7.0.97 ## explicit; go 1.23.0 github.com/minio/minio-go/v7 -github.com/minio/minio-go/v7/internal/json github.com/minio/minio-go/v7/pkg/cors github.com/minio/minio-go/v7/pkg/credentials github.com/minio/minio-go/v7/pkg/encrypt github.com/minio/minio-go/v7/pkg/kvcache github.com/minio/minio-go/v7/pkg/lifecycle github.com/minio/minio-go/v7/pkg/notification -github.com/minio/minio-go/v7/pkg/peeker github.com/minio/minio-go/v7/pkg/replication github.com/minio/minio-go/v7/pkg/s3utils github.com/minio/minio-go/v7/pkg/set @@ -737,7 +738,7 @@ github.com/modern-go/reflect2 # github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 ## explicit github.com/munnerz/goautoneg -# github.com/ncruces/go-sqlite3 v0.29.1 +# github.com/ncruces/go-sqlite3 v0.30.0 ## explicit; go 1.24.0 github.com/ncruces/go-sqlite3 github.com/ncruces/go-sqlite3/driver @@ -867,11 +868,11 @@ github.com/stretchr/testify/suite # github.com/subosito/gotenv v1.6.0 ## explicit; go 1.18 github.com/subosito/gotenv -# github.com/tdewolff/minify/v2 v2.24.5 -## explicit; go 1.17 +# github.com/tdewolff/minify/v2 v2.24.6 +## explicit; go 1.24.0 github.com/tdewolff/minify/v2 github.com/tdewolff/minify/v2/html -# github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a +# github.com/tdewolff/parse/v2 v2.8.5 ## explicit; go 1.11 github.com/tdewolff/parse/v2 github.com/tdewolff/parse/v2/buffer |