diff --git a/0001-Backport-fix-for-CVE-2024-6104.patch b/0001-Backport-fix-for-CVE-2024-6104.patch index 50564e7..7d9b67a 100644 --- a/0001-Backport-fix-for-CVE-2024-6104.patch +++ b/0001-Backport-fix-for-CVE-2024-6104.patch @@ -1,20 +1,22 @@ -From 1a3445769d0a3c392487ec9480c0bfad07bde063 Mon Sep 17 00:00:00 2001 +From 2fc0317f54fb2213d308983a04a90355fc035ae1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dan=20=C4=8Cerm=C3=A1k?= Date: Sun, 30 Jun 2024 16:09:52 +0200 -Subject: [PATCH] Backport fix for CVE-2024-6104 +Subject: [PATCH 1/5] Backport fix for CVE-2024-6104 This is https://github.com/hashicorp/go-retryablehttp/pull/158 only directly applied to the vendor/ source tree See also https://github.com/advisories/GHSA-v6v8-xj6m-xwqh + +Signed-off-by: Danish Prakash --- .../hashicorp/go-retryablehttp/client.go | 28 ++++++++++++++----- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/vendor/github.com/hashicorp/go-retryablehttp/client.go b/vendor/github.com/hashicorp/go-retryablehttp/client.go -index 12ac50bcc..efee53c40 100644 +index c9edbd0595b0..1394fbc06723 100644 --- a/vendor/github.com/hashicorp/go-retryablehttp/client.go +++ b/vendor/github.com/hashicorp/go-retryablehttp/client.go -@@ -658,9 +658,9 @@ func (c *Client) Do(req *Request) (*http.Response, error) { +@@ -609,9 +609,9 @@ func (c *Client) Do(req *Request) (*http.Response, error) { if logger != nil { switch v := logger.(type) { case LeveledLogger: @@ -26,7 +28,7 @@ index 12ac50bcc..efee53c40 100644 } } -@@ -715,9 +715,9 @@ func (c *Client) Do(req *Request) (*http.Response, error) { +@@ -666,9 +666,9 @@ func (c *Client) Do(req *Request) (*http.Response, error) { if err != nil { switch v := logger.(type) { case LeveledLogger: @@ -38,7 +40,7 @@ index 12ac50bcc..efee53c40 100644 } } else { // Call this here to maintain the behavior of logging all requests, -@@ -753,7 +753,7 @@ func (c *Client) Do(req *Request) (*http.Response, error) { +@@ -704,7 +704,7 @@ func (c *Client) Do(req *Request) (*http.Response, error) { wait := c.Backoff(c.RetryWaitMin, c.RetryWaitMax, i, resp) if logger != nil { @@ -47,7 +49,7 @@ index 12ac50bcc..efee53c40 100644 if resp != nil { desc = fmt.Sprintf("%s (status: %d)", desc, resp.StatusCode) } -@@ -818,11 +818,11 @@ func (c *Client) Do(req *Request) (*http.Response, error) { +@@ -760,11 +760,11 @@ func (c *Client) Do(req *Request) (*http.Response, error) { // communicate why if err == nil { return nil, fmt.Errorf("%s %s giving up after %d attempt(s)", @@ -61,7 +63,7 @@ index 12ac50bcc..efee53c40 100644 } // Try to read the response body so we can reuse this connection. -@@ -903,3 +903,17 @@ func (c *Client) StandardClient() *http.Client { +@@ -845,3 +845,17 @@ func (c *Client) StandardClient() *http.Client { Transport: &RoundTripper{Client: c}, } } @@ -80,5 +82,5 @@ index 12ac50bcc..efee53c40 100644 + return ru.String() +} -- -2.45.2 +2.46.0 diff --git a/0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch b/0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch new file mode 100644 index 0000000..ba5a38f --- /dev/null +++ b/0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch @@ -0,0 +1,162 @@ +From ab350f9cb65411fd1d922890b35f1e51b9f06fe7 Mon Sep 17 00:00:00 2001 +From: Paul Holzinger +Date: Thu, 3 Oct 2024 12:31:04 +0530 +Subject: [PATCH 2/5] pkg/subscriptions: use securejoin for the container path + +If we join a path from the container image we must always use securejoin +to prevent us from following a symlink onto the host. + +Fixes CVE-2024-9341 +Bugs: bsc#1231230 + +Signed-off-by: Paul Holzinger +Signed-off-by: Danish Prakash +--- + go.mod | 4 ++-- + go.sum | 8 ++++---- + .../containers/common/pkg/subscriptions/subscriptions.go | 6 +++++- + vendor/github.com/containers/common/version/version.go | 2 +- + .../containers/image/v5/docker/docker_image.go | 9 +++++++++ + vendor/github.com/containers/image/v5/version/version.go | 2 +- + vendor/modules.txt | 4 ++-- + 7 files changed, 24 insertions(+), 11 deletions(-) + +diff --git a/go.mod b/go.mod +index a84fbbb1b4bb..f765efa6a97f 100644 +--- a/go.mod ++++ b/go.mod +@@ -12,10 +12,10 @@ require ( + github.com/containernetworking/cni v1.1.2 + github.com/containernetworking/plugins v1.3.0 + github.com/containers/buildah v1.33.8 +- github.com/containers/common v0.57.5 ++ github.com/containers/common v0.57.7 + github.com/containers/conmon v2.0.20+incompatible + github.com/containers/gvisor-tap-vsock v0.7.2 +- github.com/containers/image/v5 v5.29.3 ++ github.com/containers/image/v5 v5.29.4 + github.com/containers/libhvee v0.5.0 + github.com/containers/ocicrypt v1.1.10 + github.com/containers/psgo v1.8.0 +diff --git a/go.sum b/go.sum +index 495035a32b6e..05578d2a5024 100644 +--- a/go.sum ++++ b/go.sum +@@ -260,14 +260,14 @@ github.com/containernetworking/plugins v1.3.0 h1:QVNXMT6XloyMUoO2wUOqWTC1hWFV62Q + github.com/containernetworking/plugins v1.3.0/go.mod h1:Pc2wcedTQQCVuROOOaLBPPxrEXqqXBFt3cZ+/yVg6l0= + github.com/containers/buildah v1.33.8 h1:/IfJm5gTHwWshFdRHgLTHkoHNZY85B/xePkpOypBKUw= + github.com/containers/buildah v1.33.8/go.mod h1:aS1MZukKW39pe/yeJ7sRq9Jf2Sl04uePugPIto6ItNo= +-github.com/containers/common v0.57.5 h1:EgIahxAeYpcE0JKl4A4Z2oEUseve1jt+lMuXIqYnalE= +-github.com/containers/common v0.57.5/go.mod h1:dRw+mJGANzTOJZSs+KfJzrSVNQ4zK0u46/MhLCUfzPY= ++github.com/containers/common v0.57.7 h1:xA6/dXNbScnaytcFNQKTFGn6VDxwvDlCngJtfdGAf7g= ++github.com/containers/common v0.57.7/go.mod h1:GRtgIWNPc8zmo/vcA7VoZfLWpgQRH01/kzQbeNZH8WQ= + github.com/containers/conmon v2.0.20+incompatible h1:YbCVSFSCqFjjVwHTPINGdMX1F6JXHGTUje2ZYobNrkg= + github.com/containers/conmon v2.0.20+incompatible/go.mod h1:hgwZ2mtuDrppv78a/cOBNiCm6O0UMWGx1mu7P00nu5I= + github.com/containers/gvisor-tap-vsock v0.7.2 h1:6CyU5D85C0/DciRRd7W0bPljK4FAS+DPrrHEQMHfZKY= + github.com/containers/gvisor-tap-vsock v0.7.2/go.mod h1:6NiTxh2GCVxZQLPzfuEB78/Osp2Usd9uf6nLdd6PiUY= +-github.com/containers/image/v5 v5.29.3 h1:RJHdxP+ZiC+loIFG2DTmjlVNWTS7o5jrdrRScUrY1VE= +-github.com/containers/image/v5 v5.29.3/go.mod h1:kQ7qcDsps424ZAz24thD+x7+dJw1vgur3A9tTDsj97E= ++github.com/containers/image/v5 v5.29.4 h1:EbYrwOscTvzeCXt4149OtU74T/ZuohEottcs/hz47O4= ++github.com/containers/image/v5 v5.29.4/go.mod h1:kQ7qcDsps424ZAz24thD+x7+dJw1vgur3A9tTDsj97E= + github.com/containers/libhvee v0.5.0 h1:rDhfG2NI8Q+VgeXht2dXezanxEdpj9pHqYX3vWfOGUw= + github.com/containers/libhvee v0.5.0/go.mod h1:yvU3Em2u1ZLl2VLd2glMIBWriBwfhWsDaRJsvixUIB0= + github.com/containers/libtrust v0.0.0-20230121012942-c1716e8a8d01 h1:Qzk5C6cYglewc+UyGf6lc8Mj2UaPTHy/iF2De0/77CA= +diff --git a/vendor/github.com/containers/common/pkg/subscriptions/subscriptions.go b/vendor/github.com/containers/common/pkg/subscriptions/subscriptions.go +index 6ba2154a7790..d976329f7527 100644 +--- a/vendor/github.com/containers/common/pkg/subscriptions/subscriptions.go ++++ b/vendor/github.com/containers/common/pkg/subscriptions/subscriptions.go +@@ -10,6 +10,7 @@ import ( + + "github.com/containers/common/pkg/umask" + "github.com/containers/storage/pkg/idtools" ++ securejoin "github.com/cyphar/filepath-securejoin" + rspec "github.com/opencontainers/runtime-spec/specs-go" + "github.com/opencontainers/selinux/go-selinux/label" + "github.com/sirupsen/logrus" +@@ -345,7 +346,10 @@ func addFIPSModeSubscription(mounts *[]rspec.Mount, containerRunDir, mountPoint, + + srcBackendDir := "/usr/share/crypto-policies/back-ends/FIPS" + destDir := "/etc/crypto-policies/back-ends" +- srcOnHost := filepath.Join(mountPoint, srcBackendDir) ++ srcOnHost, err := securejoin.SecureJoin(mountPoint, srcBackendDir) ++ if err != nil { ++ return fmt.Errorf("resolve %s in the container: %w", srcBackendDir, err) ++ } + if _, err := os.Stat(srcOnHost); err != nil { + if errors.Is(err, os.ErrNotExist) { + return nil +diff --git a/vendor/github.com/containers/common/version/version.go b/vendor/github.com/containers/common/version/version.go +index 9182b589f104..131d5bb4b4a4 100644 +--- a/vendor/github.com/containers/common/version/version.go ++++ b/vendor/github.com/containers/common/version/version.go +@@ -1,4 +1,4 @@ + package version + + // Version is the version of the build. +-const Version = "0.57.5" ++const Version = "0.57.7" +diff --git a/vendor/github.com/containers/image/v5/docker/docker_image.go b/vendor/github.com/containers/image/v5/docker/docker_image.go +index 4c80bb2b5251..9741afc3f099 100644 +--- a/vendor/github.com/containers/image/v5/docker/docker_image.go ++++ b/vendor/github.com/containers/image/v5/docker/docker_image.go +@@ -14,6 +14,7 @@ import ( + "github.com/containers/image/v5/manifest" + "github.com/containers/image/v5/types" + "github.com/opencontainers/go-digest" ++ "github.com/sirupsen/logrus" + ) + + // Image is a Docker-specific implementation of types.ImageCloser with a few extra methods +@@ -90,6 +91,14 @@ func GetRepositoryTags(ctx context.Context, sys *types.SystemContext, ref types. + } + for _, tag := range tagsHolder.Tags { + if _, err := reference.WithTag(dr.ref, tag); err != nil { // Ensure the tag does not contain unexpected values ++ // Per https://github.com/containers/skopeo/issues/2346 , unknown versions of JFrog Artifactory, ++ // contrary to the tag format specified in ++ // https://github.com/opencontainers/distribution-spec/blob/8a871c8234977df058f1a14e299fe0a673853da2/spec.md?plain=1#L160 , ++ // include digests in the list. ++ if _, err := digest.Parse(tag); err == nil { ++ logrus.Debugf("Ignoring invalid tag %q matching a digest format", tag) ++ continue ++ } + return nil, fmt.Errorf("registry returned invalid tag %q: %w", tag, err) + } + tags = append(tags, tag) +diff --git a/vendor/github.com/containers/image/v5/version/version.go b/vendor/github.com/containers/image/v5/version/version.go +index 62d824b3eb20..441e46706818 100644 +--- a/vendor/github.com/containers/image/v5/version/version.go ++++ b/vendor/github.com/containers/image/v5/version/version.go +@@ -8,7 +8,7 @@ const ( + // VersionMinor is for functionality in a backwards-compatible manner + VersionMinor = 29 + // VersionPatch is for backwards-compatible bug fixes +- VersionPatch = 3 ++ VersionPatch = 4 + + // VersionDev indicates development branch. Releases will be empty string. + VersionDev = "" +diff --git a/vendor/modules.txt b/vendor/modules.txt +index d99eb4f52102..c7cfc95010df 100644 +--- a/vendor/modules.txt ++++ b/vendor/modules.txt +@@ -176,7 +176,7 @@ github.com/containers/buildah/pkg/sshagent + github.com/containers/buildah/pkg/util + github.com/containers/buildah/pkg/volumes + github.com/containers/buildah/util +-# github.com/containers/common v0.57.5 ++# github.com/containers/common v0.57.7 + ## explicit; go 1.18 + github.com/containers/common/internal/attributedstring + github.com/containers/common/libimage +@@ -243,7 +243,7 @@ github.com/containers/conmon/runner/config + # github.com/containers/gvisor-tap-vsock v0.7.2 + ## explicit; go 1.20 + github.com/containers/gvisor-tap-vsock/pkg/types +-# github.com/containers/image/v5 v5.29.3 ++# github.com/containers/image/v5 v5.29.4 + ## explicit; go 1.19 + github.com/containers/image/v5/copy + github.com/containers/image/v5/directory +-- +2.46.0 + diff --git a/0003-CVE-2024-9407-validate-bind-propagation-flag-setting.patch b/0003-CVE-2024-9407-validate-bind-propagation-flag-setting.patch new file mode 100644 index 0000000..231cae5 --- /dev/null +++ b/0003-CVE-2024-9407-validate-bind-propagation-flag-setting.patch @@ -0,0 +1,49 @@ +From 5aebc47dcd2b90460967cea48b713a4a88f93657 Mon Sep 17 00:00:00 2001 +From: Danish Prakash +Date: Wed, 16 Oct 2024 14:49:01 +0530 +Subject: [PATCH 3/5] CVE-2024-9407: validate "bind-propagation" flag settings + +CVE-2024-9407: validate that the value for the "bind-propagation" flag +when handling "bind" and "cache" mounts in `buildah run` or in RUN +instructions is one of the values that we would accept without the +"bind-propagation=" prefix. + +Signed-off-by: Nalin Dahyabhai +Signed-off-by: Danish Prakash +--- + .../containers/buildah/internal/volumes/volumes.go | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/vendor/github.com/containers/buildah/internal/volumes/volumes.go b/vendor/github.com/containers/buildah/internal/volumes/volumes.go +index fd1ff7f98592..554c9ac0debc 100644 +--- a/vendor/github.com/containers/buildah/internal/volumes/volumes.go ++++ b/vendor/github.com/containers/buildah/internal/volumes/volumes.go +@@ -101,6 +101,12 @@ func GetBindMount(ctx *types.SystemContext, args []string, contextDir string, st + if len(kv) == 1 { + return newMount, "", fmt.Errorf("%v: %w", kv[0], errBadOptionArg) + } ++ switch kv[1] { ++ default: ++ return newMount, "", fmt.Errorf("%v: %q: %w", kv[0], kv[1], errBadMntOption) ++ case "shared", "rshared", "private", "rprivate", "slave", "rslave": ++ // this should be the relevant parts of the same list of options we accepted above ++ } + newMount.Options = append(newMount.Options, kv[1]) + case "src", "source": + if len(kv) == 1 { +@@ -276,6 +282,12 @@ func GetCacheMount(args []string, store storage.Store, imageMountLabel string, a + if len(kv) == 1 { + return newMount, nil, fmt.Errorf("%v: %w", kv[0], errBadOptionArg) + } ++ switch kv[1] { ++ default: ++ return newMount, nil, fmt.Errorf("%v: %q: %w", kv[0], kv[1], errBadMntOption) ++ case "shared", "rshared", "private", "rprivate", "slave", "rslave": ++ // this should be the relevant parts of the same list of options we accepted above ++ } + newMount.Options = append(newMount.Options, kv[1]) + case "id": + if len(kv) == 1 { +-- +2.46.0 + diff --git a/0004-Properly-validate-cache-IDs-and-sources.patch b/0004-Properly-validate-cache-IDs-and-sources.patch new file mode 100644 index 0000000..0ab92d9 --- /dev/null +++ b/0004-Properly-validate-cache-IDs-and-sources.patch @@ -0,0 +1,68 @@ +From 07bc2d7e8860729723c181653e8416ee0eba4070 Mon Sep 17 00:00:00 2001 +From: Danish Prakash +Date: Tue, 15 Oct 2024 22:23:52 +0530 +Subject: [PATCH 4/5] Properly validate cache IDs and sources + +The `--mount type=cache` argument to the `RUN` instruction in +Dockerfiles was using `filepath.Join` on user input, allowing +crafted paths to be used to gain access to paths on the host, +when the command should normally be limited only to Buildah;s own +cache and context directories. Switch to `filepath.SecureJoin` to +resolve the issue. + +Fixes CVE-2024-9675 + +Signed-off-by: Matt Heon +Signed-off-by: Danish Prakash +--- + .../buildah/internal/volumes/volumes.go | 19 ++++++++++++++----- + 1 file changed, 14 insertions(+), 5 deletions(-) + +diff --git a/vendor/github.com/containers/buildah/internal/volumes/volumes.go b/vendor/github.com/containers/buildah/internal/volumes/volumes.go +index 554c9ac0debc..f20b254ef7d9 100644 +--- a/vendor/github.com/containers/buildah/internal/volumes/volumes.go ++++ b/vendor/github.com/containers/buildah/internal/volumes/volumes.go +@@ -23,6 +23,7 @@ import ( + "github.com/containers/storage/pkg/idtools" + "github.com/containers/storage/pkg/lockfile" + "github.com/containers/storage/pkg/unshare" ++ digest "github.com/opencontainers/go-digest" + specs "github.com/opencontainers/runtime-spec/specs-go" + selinux "github.com/opencontainers/selinux/go-selinux" + ) +@@ -373,7 +374,11 @@ func GetCacheMount(args []string, store storage.Store, imageMountLabel string, a + return newMount, nil, fmt.Errorf("no stage found with name %s", fromStage) + } + // path should be /contextDir/specified path +- newMount.Source = filepath.Join(mountPoint, filepath.Clean(string(filepath.Separator)+newMount.Source)) ++ evaluated, err := copier.Eval(mountPoint, string(filepath.Separator)+newMount.Source, copier.EvalOptions{}) ++ if err != nil { ++ return newMount, nil, err ++ } ++ newMount.Source = evaluated + } else { + // we need to create cache on host if no image is being used + +@@ -390,11 +395,15 @@ func GetCacheMount(args []string, store storage.Store, imageMountLabel string, a + } + + if id != "" { +- newMount.Source = filepath.Join(cacheParent, filepath.Clean(id)) +- buildahLockFilesDir = filepath.Join(BuildahCacheLockfileDir, filepath.Clean(id)) ++ // Don't let the user control where we place the directory. ++ dirID := digest.FromString(id).Encoded()[:16] ++ newMount.Source = filepath.Join(cacheParent, dirID) ++ buildahLockFilesDir = filepath.Join(BuildahCacheLockfileDir, dirID) + } else { +- newMount.Source = filepath.Join(cacheParent, filepath.Clean(newMount.Destination)) +- buildahLockFilesDir = filepath.Join(BuildahCacheLockfileDir, filepath.Clean(newMount.Destination)) ++ // Don't let the user control where we place the directory. ++ dirID := digest.FromString(newMount.Destination).Encoded()[:16] ++ newMount.Source = filepath.Join(cacheParent, dirID) ++ buildahLockFilesDir = filepath.Join(BuildahCacheLockfileDir, dirID) + } + idPair := idtools.IDPair{ + UID: uid, +-- +2.46.0 + diff --git a/0005-Use-securejoin.SecureJoin-when-forming-userns-paths.patch b/0005-Use-securejoin.SecureJoin-when-forming-userns-paths.patch new file mode 100644 index 0000000..d7916c3 --- /dev/null +++ b/0005-Use-securejoin.SecureJoin-when-forming-userns-paths.patch @@ -0,0 +1,19466 @@ +From 8439966e6f723918b2b58ed84dd24e53b3b23417 Mon Sep 17 00:00:00 2001 +From: Danish Prakash +Date: Tue, 22 Oct 2024 12:01:05 +0530 +Subject: [PATCH 5/5] Use securejoin.SecureJoin when forming userns paths + +We need to read /etc/passwd and /etc/group in the container to +get an idea of how many UIDs and GIDs we need to allocate for a +user namespace when `--userns=auto` is specified. We were forming +paths for these using filepath.Join, which is not safe for paths +within a container, resulting in this CVE allowing crafted +symlinks in the container to access paths on the host instead. + +cyphar/filepath-securejoin bump to required 0.3.0 + +Addresses CVE-2024-9676 +Bugs: bsc#1231698 + +Signed-off-by: Matt Heon +Signed-off-by: Danish Prakash +--- + go.mod | 6 +- + go.sum | 10 +- + .../github.com/containers/storage/.cirrus.yml | 2 +- + .../github.com/containers/storage/userns.go | 87 +- + .../containers/storage/userns_unsupported.go | 14 + + .../cyphar/filepath-securejoin/LICENSE | 2 +- + .../cyphar/filepath-securejoin/README.md | 139 +- + .../cyphar/filepath-securejoin/VERSION | 2 +- + .../cyphar/filepath-securejoin/join.go | 85 +- + .../filepath-securejoin/lookup_linux.go | 380 ++ + .../cyphar/filepath-securejoin/mkdir_linux.go | 228 + + .../cyphar/filepath-securejoin/open_linux.go | 83 + + .../filepath-securejoin/openat2_linux.go | 128 + + .../filepath-securejoin/openat_linux.go | 59 + + .../filepath-securejoin/procfs_linux.go | 481 ++ + .../testing_mocks_linux.go | 68 + + .../cyphar/filepath-securejoin/vfs.go | 2 +- + .../hashicorp/go-retryablehttp/client.go | 28 +- + .../testify/assert/assertion_compare.go | 28 +- + .../assert/assertion_compare_can_convert.go | 16 - + .../assert/assertion_compare_legacy.go | 16 - + .../testify/assert/assertion_format.go | 32 +- + .../testify/assert/assertion_forward.go | 59 +- + .../stretchr/testify/assert/assertions.go | 207 +- + .../testify/assert/http_assertions.go | 27 +- + .../stretchr/testify/require/require.go | 65 +- + .../testify/require/require_forward.go | 59 +- + vendor/golang.org/x/sys/cpu/cpu.go | 1 + + vendor/golang.org/x/sys/cpu/cpu_arm64.go | 10 + + vendor/golang.org/x/sys/cpu/cpu_arm64.s | 8 + + vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go | 1 + + .../golang.org/x/sys/cpu/cpu_linux_arm64.go | 5 + + vendor/golang.org/x/sys/unix/aliases.go | 2 +- + vendor/golang.org/x/sys/unix/asm_zos_s390x.s | 665 +- + vendor/golang.org/x/sys/unix/bpxsvc_zos.go | 657 ++ + vendor/golang.org/x/sys/unix/bpxsvc_zos.s | 192 + + vendor/golang.org/x/sys/unix/epoll_zos.go | 220 - + vendor/golang.org/x/sys/unix/fstatfs_zos.go | 163 - + vendor/golang.org/x/sys/unix/mkerrors.sh | 2 + + vendor/golang.org/x/sys/unix/mmap_nomremap.go | 2 +- + vendor/golang.org/x/sys/unix/pagesize_unix.go | 2 +- + .../x/sys/unix/readdirent_getdirentries.go | 2 +- + vendor/golang.org/x/sys/unix/sockcmsg_zos.go | 58 + + .../golang.org/x/sys/unix/symaddr_zos_s390x.s | 75 + + .../x/sys/unix/syscall_darwin_libSystem.go | 2 +- + .../golang.org/x/sys/unix/syscall_freebsd.go | 12 +- + vendor/golang.org/x/sys/unix/syscall_linux.go | 99 + + .../x/sys/unix/syscall_zos_s390x.go | 1509 ++++- + vendor/golang.org/x/sys/unix/sysvshm_unix.go | 2 +- + .../x/sys/unix/sysvshm_unix_other.go | 2 +- + vendor/golang.org/x/sys/unix/zerrors_linux.go | 29 +- + .../x/sys/unix/zerrors_linux_386.go | 1 + + .../x/sys/unix/zerrors_linux_amd64.go | 1 + + .../x/sys/unix/zerrors_linux_arm64.go | 1 + + .../x/sys/unix/zerrors_zos_s390x.go | 233 +- + .../x/sys/unix/zsymaddr_zos_s390x.s | 364 ++ + .../golang.org/x/sys/unix/zsyscall_linux.go | 10 + + .../x/sys/unix/zsyscall_zos_s390x.go | 3113 ++++++++-- + .../x/sys/unix/zsysnum_linux_386.go | 5 + + .../x/sys/unix/zsysnum_linux_amd64.go | 5 + + .../x/sys/unix/zsysnum_linux_arm.go | 5 + + .../x/sys/unix/zsysnum_linux_arm64.go | 5 + + .../x/sys/unix/zsysnum_linux_loong64.go | 5 + + .../x/sys/unix/zsysnum_linux_mips.go | 5 + + .../x/sys/unix/zsysnum_linux_mips64.go | 5 + + .../x/sys/unix/zsysnum_linux_mips64le.go | 5 + + .../x/sys/unix/zsysnum_linux_mipsle.go | 5 + + .../x/sys/unix/zsysnum_linux_ppc.go | 5 + + .../x/sys/unix/zsysnum_linux_ppc64.go | 5 + + .../x/sys/unix/zsysnum_linux_ppc64le.go | 5 + + .../x/sys/unix/zsysnum_linux_riscv64.go | 5 + + .../x/sys/unix/zsysnum_linux_s390x.go | 5 + + .../x/sys/unix/zsysnum_linux_sparc64.go | 5 + + .../x/sys/unix/zsysnum_zos_s390x.go | 5507 +++++++++-------- + vendor/golang.org/x/sys/unix/ztypes_linux.go | 119 +- + .../golang.org/x/sys/unix/ztypes_linux_386.go | 8 - + .../x/sys/unix/ztypes_linux_amd64.go | 9 - + .../golang.org/x/sys/unix/ztypes_linux_arm.go | 9 - + .../x/sys/unix/ztypes_linux_arm64.go | 9 - + .../x/sys/unix/ztypes_linux_loong64.go | 9 - + .../x/sys/unix/ztypes_linux_mips.go | 9 - + .../x/sys/unix/ztypes_linux_mips64.go | 9 - + .../x/sys/unix/ztypes_linux_mips64le.go | 9 - + .../x/sys/unix/ztypes_linux_mipsle.go | 9 - + .../golang.org/x/sys/unix/ztypes_linux_ppc.go | 9 - + .../x/sys/unix/ztypes_linux_ppc64.go | 9 - + .../x/sys/unix/ztypes_linux_ppc64le.go | 9 - + .../x/sys/unix/ztypes_linux_riscv64.go | 9 - + .../x/sys/unix/ztypes_linux_s390x.go | 9 - + .../x/sys/unix/ztypes_linux_sparc64.go | 9 - + .../golang.org/x/sys/unix/ztypes_zos_s390x.go | 146 +- + vendor/golang.org/x/sys/windows/aliases.go | 2 +- + vendor/golang.org/x/sys/windows/empty.s | 8 - + .../x/sys/windows/security_windows.go | 1 + + .../x/sys/windows/syscall_windows.go | 82 + + .../golang.org/x/sys/windows/types_windows.go | 24 + + .../x/sys/windows/zsyscall_windows.go | 135 +- + vendor/modules.txt | 10 +- + 98 files changed, 11409 insertions(+), 4590 deletions(-) + create mode 100644 vendor/github.com/containers/storage/userns_unsupported.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/lookup_linux.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/mkdir_linux.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/open_linux.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/openat2_linux.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/openat_linux.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/procfs_linux.go + create mode 100644 vendor/github.com/cyphar/filepath-securejoin/testing_mocks_linux.go + delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_compare_can_convert.go + delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_compare_legacy.go + create mode 100644 vendor/golang.org/x/sys/unix/bpxsvc_zos.go + create mode 100644 vendor/golang.org/x/sys/unix/bpxsvc_zos.s + delete mode 100644 vendor/golang.org/x/sys/unix/epoll_zos.go + delete mode 100644 vendor/golang.org/x/sys/unix/fstatfs_zos.go + create mode 100644 vendor/golang.org/x/sys/unix/sockcmsg_zos.go + create mode 100644 vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s + create mode 100644 vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s + delete mode 100644 vendor/golang.org/x/sys/windows/empty.s + +diff --git a/go.mod b/go.mod +index f765efa6a97f..46d885581824 100644 +--- a/go.mod ++++ b/go.mod +@@ -23,7 +23,7 @@ require ( + github.com/coreos/go-systemd/v22 v22.5.1-0.20231103132048-7d375ecc2b09 + github.com/coreos/stream-metadata-go v0.4.4 + github.com/crc-org/vfkit v0.1.2-0.20231030102423-f3c783d34420 +- github.com/cyphar/filepath-securejoin v0.2.4 ++ github.com/cyphar/filepath-securejoin v0.3.0 + github.com/digitalocean/go-qemu v0.0.0-20230711162256-2e3d0186973e + github.com/docker/distribution v2.8.3+incompatible + github.com/docker/docker v24.0.7+incompatible +@@ -60,7 +60,7 @@ require ( + github.com/sirupsen/logrus v1.9.3 + github.com/spf13/cobra v1.8.0 + github.com/spf13/pflag v1.0.5 +- github.com/stretchr/testify v1.8.4 ++ github.com/stretchr/testify v1.9.0 + github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 + github.com/ulikunitz/xz v0.5.11 + github.com/vbauerster/mpb/v8 v8.6.2 +@@ -69,7 +69,7 @@ require ( + golang.org/x/exp v0.0.0-20231006140011-7918f672742d + golang.org/x/net v0.18.0 + golang.org/x/sync v0.6.0 +- golang.org/x/sys v0.17.0 ++ golang.org/x/sys v0.21.0 + golang.org/x/term v0.17.0 + golang.org/x/text v0.14.0 + google.golang.org/protobuf v1.33.0 +diff --git a/go.sum b/go.sum +index 05578d2a5024..26049924e5b3 100644 +--- a/go.sum ++++ b/go.sum +@@ -319,8 +319,8 @@ github.com/cyberphone/json-canonicalization v0.0.0-20231011164504-785e29786b46 h + github.com/cyberphone/json-canonicalization v0.0.0-20231011164504-785e29786b46/go.mod h1:uzvlm1mxhHkdfqitSA92i7Se+S9ksOn3a3qmv/kyOCw= + github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4= + github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= +-github.com/cyphar/filepath-securejoin v0.2.4 h1:Ugdm7cg7i6ZK6x3xDF1oEu1nfkyfH53EtKeQYTC3kyg= +-github.com/cyphar/filepath-securejoin v0.2.4/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= ++github.com/cyphar/filepath-securejoin v0.3.0 h1:tXpmbiaeBrS/K2US8nhgwdKYnfAOnVfkcLPKFgFHeA0= ++github.com/cyphar/filepath-securejoin v0.3.0/go.mod h1:F7i41x/9cBF7lzCrVsYs9fuzwRZm4NQsGTBdpp6mETc= + github.com/d2g/dhcp4 v0.0.0-20170904100407-a1d1b6c41b1c/go.mod h1:Ct2BUK8SB0YC1SMSibvLzxjeJLnrYEVLULFNiHY9YfQ= + github.com/d2g/dhcp4client v1.0.0/go.mod h1:j0hNfjhrt2SxUOw55nL0ATM/z4Yt3t2Kd1mW34z5W5s= + github.com/d2g/dhcp4server v0.0.0-20181031114812-7d4a0a7f59a5/go.mod h1:Eo87+Kg/IX2hfWJfwxMzLyuSZyxSoAug2nGa1G2QAi8= +@@ -1040,8 +1040,9 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ + github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= + github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= + github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= + github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= ++github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= ++github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= + github.com/sylabs/sif/v2 v2.15.0 h1:Nv0tzksFnoQiQ2eUwpAis9nVqEu4c3RcNSxX8P3Cecw= + github.com/sylabs/sif/v2 v2.15.0/go.mod h1:X1H7eaPz6BAxA84POMESXoXfTqgAnLQkujyF/CQFWTc= + github.com/syndtr/gocapability v0.0.0-20170704070218-db04d3cc01c8/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= +@@ -1386,8 +1387,9 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= + golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= + golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= + golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +-golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= + golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= ++golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= ++golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= + golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= + golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= + golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +diff --git a/vendor/github.com/containers/storage/.cirrus.yml b/vendor/github.com/containers/storage/.cirrus.yml +index c41dd5da2c52..a5231414b701 100644 +--- a/vendor/github.com/containers/storage/.cirrus.yml ++++ b/vendor/github.com/containers/storage/.cirrus.yml +@@ -119,7 +119,7 @@ lint_task: + env: + CIRRUS_WORKING_DIR: "/go/src/github.com/containers/storage" + container: +- image: golang ++ image: golang:1.21 + modules_cache: + fingerprint_script: cat go.sum + folder: $GOPATH/pkg/mod +diff --git a/vendor/github.com/containers/storage/userns.go b/vendor/github.com/containers/storage/userns.go +index 32ae830beaec..b0f8d59a4ace 100644 +--- a/vendor/github.com/containers/storage/userns.go ++++ b/vendor/github.com/containers/storage/userns.go +@@ -1,18 +1,21 @@ ++//go:build linux ++ + package storage + + import ( + "fmt" + "os" + "os/user" +- "path/filepath" + "strconv" + + drivers "github.com/containers/storage/drivers" + "github.com/containers/storage/pkg/idtools" + "github.com/containers/storage/pkg/unshare" + "github.com/containers/storage/types" ++ securejoin "github.com/cyphar/filepath-securejoin" + libcontainerUser "github.com/opencontainers/runc/libcontainer/user" + "github.com/sirupsen/logrus" ++ "golang.org/x/sys/unix" + ) + + // getAdditionalSubIDs looks up the additional IDs configured for +@@ -85,40 +88,59 @@ const nobodyUser = 65534 + // parseMountedFiles returns the maximum UID and GID found in the /etc/passwd and + // /etc/group files. + func parseMountedFiles(containerMount, passwdFile, groupFile string) uint32 { ++ var ( ++ passwd *os.File ++ group *os.File ++ size int ++ err error ++ ) + if passwdFile == "" { +- passwdFile = filepath.Join(containerMount, "etc/passwd") +- } +- if groupFile == "" { +- groupFile = filepath.Join(groupFile, "etc/group") ++ passwd, err = secureOpen(containerMount, "/etc/passwd") ++ } else { ++ // User-specified override from a volume. Will not be in ++ // container root. ++ passwd, err = os.Open(passwdFile) + } +- +- size := 0 +- +- users, err := libcontainerUser.ParsePasswdFile(passwdFile) + if err == nil { +- for _, u := range users { +- // Skip the "nobody" user otherwise we end up with 65536 +- // ids with most images +- if u.Name == "nobody" { +- continue +- } +- if u.Uid > size && u.Uid != nobodyUser { +- size = u.Uid +- } +- if u.Gid > size && u.Gid != nobodyUser { +- size = u.Gid ++ defer passwd.Close() ++ ++ users, err := libcontainerUser.ParsePasswd(passwd) ++ if err == nil { ++ for _, u := range users { ++ // Skip the "nobody" user otherwise we end up with 65536 ++ // ids with most images ++ if u.Name == "nobody" || u.Name == "nogroup" { ++ continue ++ } ++ if u.Uid > size && u.Uid != nobodyUser { ++ size = u.Uid + 1 ++ } ++ if u.Gid > size && u.Gid != nobodyUser { ++ size = u.Gid + 1 ++ } + } + } + } + +- groups, err := libcontainerUser.ParseGroupFile(groupFile) ++ if groupFile == "" { ++ group, err = secureOpen(containerMount, "/etc/group") ++ } else { ++ // User-specified override from a volume. Will not be in ++ // container root. ++ group, err = os.Open(groupFile) ++ } + if err == nil { +- for _, g := range groups { +- if g.Name == "nobody" { +- continue +- } +- if g.Gid > size && g.Gid != nobodyUser { +- size = g.Gid ++ defer group.Close() ++ ++ groups, err := libcontainerUser.ParseGroup(group) ++ if err == nil { ++ for _, g := range groups { ++ if g.Name == "nobody" || g.Name == "nogroup" { ++ continue ++ } ++ if g.Gid > size && g.Gid != nobodyUser { ++ size = g.Gid + 1 ++ } + } + } + } +@@ -309,3 +331,14 @@ func getAutoUserNSIDMappings( + gidMap := append(availableGIDs.zip(requestedContainerGIDs), additionalGIDMappings...) + return uidMap, gidMap, nil + } ++ ++// Securely open (read-only) a file in a container mount. ++func secureOpen(containerMount, file string) (*os.File, error) { ++ tmpFile, err := securejoin.OpenInRoot(containerMount, file) ++ if err != nil { ++ return nil, err ++ } ++ defer tmpFile.Close() ++ ++ return securejoin.Reopen(tmpFile, unix.O_RDONLY) ++} +diff --git a/vendor/github.com/containers/storage/userns_unsupported.go b/vendor/github.com/containers/storage/userns_unsupported.go +new file mode 100644 +index 000000000000..e37c18fe4381 +--- /dev/null ++++ b/vendor/github.com/containers/storage/userns_unsupported.go +@@ -0,0 +1,14 @@ ++//go:build !linux ++ ++package storage ++ ++import ( ++ "errors" ++ ++ "github.com/containers/storage/pkg/idtools" ++ "github.com/containers/storage/types" ++) ++ ++func (s *store) getAutoUserNS(_ *types.AutoUserNsOptions, _ *Image, _ rwLayerStore, _ []roLayerStore) ([]idtools.IDMap, []idtools.IDMap, error) { ++ return nil, nil, errors.New("user namespaces are not supported on this platform") ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/LICENSE b/vendor/github.com/cyphar/filepath-securejoin/LICENSE +index bec842f294f7..cb1ab88da0fa 100644 +--- a/vendor/github.com/cyphar/filepath-securejoin/LICENSE ++++ b/vendor/github.com/cyphar/filepath-securejoin/LICENSE +@@ -1,5 +1,5 @@ + Copyright (C) 2014-2015 Docker Inc & Go Authors. All rights reserved. +-Copyright (C) 2017 SUSE LLC. All rights reserved. ++Copyright (C) 2017-2024 SUSE LLC. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are +diff --git a/vendor/github.com/cyphar/filepath-securejoin/README.md b/vendor/github.com/cyphar/filepath-securejoin/README.md +index 4eca0f235502..253956f86576 100644 +--- a/vendor/github.com/cyphar/filepath-securejoin/README.md ++++ b/vendor/github.com/cyphar/filepath-securejoin/README.md +@@ -2,31 +2,24 @@ + + [![Build Status](https://github.com/cyphar/filepath-securejoin/actions/workflows/ci.yml/badge.svg)](https://github.com/cyphar/filepath-securejoin/actions/workflows/ci.yml) + +-An implementation of `SecureJoin`, a [candidate for inclusion in the Go +-standard library][go#20126]. The purpose of this function is to be a "secure" +-alternative to `filepath.Join`, and in particular it provides certain +-guarantees that are not provided by `filepath.Join`. +- +-> **NOTE**: This code is *only* safe if you are not at risk of other processes +-> modifying path components after you've used `SecureJoin`. If it is possible +-> for a malicious process to modify path components of the resolved path, then +-> you will be vulnerable to some fairly trivial TOCTOU race conditions. [There +-> are some Linux kernel patches I'm working on which might allow for a better +-> solution.][lwn-obeneath] +-> +-> In addition, with a slightly modified API it might be possible to use +-> `O_PATH` and verify that the opened path is actually the resolved one -- but +-> I have not done that yet. I might add it in the future as a helper function +-> to help users verify the path (we can't just return `/proc/self/fd/` +-> because that doesn't always work transparently for all users). +- +-This is the function prototype: ++### Old API ### + +-```go +-func SecureJoin(root, unsafePath string) (string, error) +-``` ++This library was originally just an implementation of `SecureJoin` which was ++[intended to be included in the Go standard library][go#20126] as a safer ++`filepath.Join` that would restrict the path lookup to be inside a root ++directory. ++ ++The implementation was based on code that existed in several container ++runtimes. Unfortunately, this API is **fundamentally unsafe** against attackers ++that can modify path components after `SecureJoin` returns and before the ++caller uses the path, allowing for some fairly trivial TOCTOU attacks. ++ ++`SecureJoin` (and `SecureJoinVFS`) are still provided by this library to ++support legacy users, but new users are strongly suggested to avoid using ++`SecureJoin` and instead use the [new api](#new-api) or switch to ++[libpathrs][libpathrs]. + +-This library **guarantees** the following: ++With the above limitations in mind, this library guarantees the following: + + * If no error is set, the resulting string **must** be a child path of + `root` and will not contain any symlink path components (they will all be +@@ -47,7 +40,7 @@ This library **guarantees** the following: + A (trivial) implementation of this function on GNU/Linux systems could be done + with the following (note that this requires root privileges and is far more + opaque than the implementation in this library, and also requires that +-`readlink` is inside the `root` path): ++`readlink` is inside the `root` path and is trustworthy): + + ```go + package securejoin +@@ -70,9 +63,105 @@ func SecureJoin(root, unsafePath string) (string, error) { + } + ``` + +-[lwn-obeneath]: https://lwn.net/Articles/767547/ ++[libpathrs]: https://github.com/openSUSE/libpathrs + [go#20126]: https://github.com/golang/go/issues/20126 + ++### New API ### ++ ++While we recommend users switch to [libpathrs][libpathrs] as soon as it has a ++stable release, some methods implemented by libpathrs have been ported to this ++library to ease the transition. These APIs are only supported on Linux. ++ ++These APIs are implemented such that `filepath-securejoin` will ++opportunistically use certain newer kernel APIs that make these operations far ++more secure. In particular: ++ ++* All of the lookup operations will use [`openat2`][openat2.2] on new enough ++ kernels (Linux 5.6 or later) to restrict lookups through magic-links and ++ bind-mounts (for certain operations) and to make use of `RESOLVE_IN_ROOT` to ++ efficiently resolve symlinks within a rootfs. ++ ++* The APIs provide hardening against a malicious `/proc` mount to either detect ++ or avoid being tricked by a `/proc` that is not legitimate. This is done ++ using [`openat2`][openat2.2] for all users, and privileged users will also be ++ further protected by using [`fsopen`][fsopen.2] and [`open_tree`][open_tree.2] ++ (Linux 4.18 or later). ++ ++[openat2.2]: https://www.man7.org/linux/man-pages/man2/openat2.2.html ++[fsopen.2]: https://github.com/brauner/man-pages-md/blob/main/fsopen.md ++[open_tree.2]: https://github.com/brauner/man-pages-md/blob/main/open_tree.md ++ ++#### `OpenInRoot` #### ++ ++```go ++func OpenInRoot(root, unsafePath string) (*os.File, error) ++func OpenatInRoot(root *os.File, unsafePath string) (*os.File, error) ++func Reopen(handle *os.File, flags int) (*os.File, error) ++``` ++ ++`OpenInRoot` is a much safer version of ++ ++```go ++path, err := securejoin.SecureJoin(root, unsafePath) ++file, err := os.OpenFile(path, unix.O_PATH|unix.O_CLOEXEC) ++``` ++ ++that protects against various race attacks that could lead to serious security ++issues, depending on the application. Note that the returned `*os.File` is an ++`O_PATH` file descriptor, which is quite restricted. Callers will probably need ++to use `Reopen` to get a more usable handle (this split is done to provide ++useful features like PTY spawning and to avoid users accidentally opening bad ++inodes that could cause a DoS). ++ ++Callers need to be careful in how they use the returned `*os.File`. Usually it ++is only safe to operate on the handle directly, and it is very easy to create a ++security issue. [libpathrs][libpathrs] provides far more helpers to make using ++these handles safer -- there is currently no plan to port them to ++`filepath-securejoin`. ++ ++`OpenatInRoot` is like `OpenInRoot` except that the root is provided using an ++`*os.File`. This allows you to ensure that multiple `OpenatInRoot` (or ++`MkdirAllHandle`) calls are operating on the same rootfs. ++ ++> **NOTE**: Unlike `SecureJoin`, `OpenInRoot` will error out as soon as it hits ++> a dangling symlink or non-existent path. This is in contrast to `SecureJoin` ++> which treated non-existent components as though they were real directories, ++> and would allow for partial resolution of dangling symlinks. These behaviours ++> are at odds with how Linux treats non-existent paths and dangling symlinks, ++> and so these are no longer allowed. ++ ++#### `MkdirAll` #### ++ ++```go ++func MkdirAll(root, unsafePath string, mode int) error ++func MkdirAllHandle(root *os.File, unsafePath string, mode int) (*os.File, error) ++``` ++ ++`MkdirAll` is a much safer version of ++ ++```go ++path, err := securejoin.SecureJoin(root, unsafePath) ++err = os.MkdirAll(path, mode) ++``` ++ ++that protects against the same kinds of races that `OpenInRoot` protects ++against. ++ ++`MkdirAllHandle` is like `MkdirAll` except that the root is provided using an ++`*os.File` (the reason for this is the same as with `OpenatInRoot`) and an ++`*os.File` of the final created directory is returned (this directory is ++guaranteed to be effectively identical to the directory created by ++`MkdirAllHandle`, which is not possible to ensure by just using `OpenatInRoot` ++after `MkdirAll`). ++ ++> **NOTE**: Unlike `SecureJoin`, `MkdirAll` will error out as soon as it hits ++> a dangling symlink or non-existent path. This is in contrast to `SecureJoin` ++> which treated non-existent components as though they were real directories, ++> and would allow for partial resolution of dangling symlinks. These behaviours ++> are at odds with how Linux treats non-existent paths and dangling symlinks, ++> and so these are no longer allowed. This means that `MkdirAll` will not ++> create non-existent directories referenced by a dangling symlink. ++ + ### License ### + + The license of this project is the same as Go, which is a BSD 3-clause license +diff --git a/vendor/github.com/cyphar/filepath-securejoin/VERSION b/vendor/github.com/cyphar/filepath-securejoin/VERSION +index abd410582dea..0d91a54c7d43 100644 +--- a/vendor/github.com/cyphar/filepath-securejoin/VERSION ++++ b/vendor/github.com/cyphar/filepath-securejoin/VERSION +@@ -1 +1 @@ +-0.2.4 ++0.3.0 +diff --git a/vendor/github.com/cyphar/filepath-securejoin/join.go b/vendor/github.com/cyphar/filepath-securejoin/join.go +index aa32b85fb84c..bd86a48b0cc1 100644 +--- a/vendor/github.com/cyphar/filepath-securejoin/join.go ++++ b/vendor/github.com/cyphar/filepath-securejoin/join.go +@@ -1,5 +1,5 @@ + // Copyright (C) 2014-2015 Docker Inc & Go Authors. All rights reserved. +-// Copyright (C) 2017 SUSE LLC. All rights reserved. ++// Copyright (C) 2017-2024 SUSE LLC. All rights reserved. + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +@@ -11,7 +11,6 @@ + package securejoin + + import ( +- "bytes" + "errors" + "os" + "path/filepath" +@@ -19,6 +18,8 @@ import ( + "syscall" + ) + ++const maxSymlinkLimit = 255 ++ + // IsNotExist tells you if err is an error that implies that either the path + // accessed does not exist (or path components don't exist). This is + // effectively a more broad version of os.IsNotExist. +@@ -40,6 +41,12 @@ func IsNotExist(err error) bool { + // replaced with symlinks on the filesystem) after this function has returned. + // Such a symlink race is necessarily out-of-scope of SecureJoin. + // ++// NOTE: Due to the above limitation, Linux users are strongly encouraged to ++// use OpenInRoot instead, which does safely protect against these kinds of ++// attacks. There is no way to solve this problem with SecureJoinVFS because ++// the API is fundamentally wrong (you cannot return a "safe" path string and ++// guarantee it won't be modified afterwards). ++// + // Volume names in unsafePath are always discarded, regardless if they are + // provided via direct input or when evaluating symlinks. Therefore: + // +@@ -51,71 +58,69 @@ func SecureJoinVFS(root, unsafePath string, vfs VFS) (string, error) { + } + + unsafePath = filepath.FromSlash(unsafePath) +- var path bytes.Buffer +- n := 0 +- for unsafePath != "" { +- if n > 255 { +- return "", &os.PathError{Op: "SecureJoin", Path: root + string(filepath.Separator) + unsafePath, Err: syscall.ELOOP} ++ var ( ++ currentPath string ++ remainingPath = unsafePath ++ linksWalked int ++ ) ++ for remainingPath != "" { ++ if v := filepath.VolumeName(remainingPath); v != "" { ++ remainingPath = remainingPath[len(v):] + } + +- if v := filepath.VolumeName(unsafePath); v != "" { +- unsafePath = unsafePath[len(v):] +- } +- +- // Next path component, p. +- i := strings.IndexRune(unsafePath, filepath.Separator) +- var p string +- if i == -1 { +- p, unsafePath = unsafePath, "" ++ // Get the next path component. ++ var part string ++ if i := strings.IndexRune(remainingPath, filepath.Separator); i == -1 { ++ part, remainingPath = remainingPath, "" + } else { +- p, unsafePath = unsafePath[:i], unsafePath[i+1:] ++ part, remainingPath = remainingPath[:i], remainingPath[i+1:] + } + +- // Create a cleaned path, using the lexical semantics of /../a, to +- // create a "scoped" path component which can safely be joined to fullP +- // for evaluation. At this point, path.String() doesn't contain any +- // symlink components. +- cleanP := filepath.Clean(string(filepath.Separator) + path.String() + p) +- if cleanP == string(filepath.Separator) { +- path.Reset() ++ // Apply the component lexically to the path we are building. ++ // currentPath does not contain any symlinks, and we are lexically ++ // dealing with a single component, so it's okay to do a filepath.Clean ++ // here. ++ nextPath := filepath.Join(string(filepath.Separator), currentPath, part) ++ if nextPath == string(filepath.Separator) { ++ currentPath = "" + continue + } +- fullP := filepath.Clean(root + cleanP) ++ fullPath := root + string(filepath.Separator) + nextPath + + // Figure out whether the path is a symlink. +- fi, err := vfs.Lstat(fullP) ++ fi, err := vfs.Lstat(fullPath) + if err != nil && !IsNotExist(err) { + return "", err + } + // Treat non-existent path components the same as non-symlinks (we + // can't do any better here). + if IsNotExist(err) || fi.Mode()&os.ModeSymlink == 0 { +- path.WriteString(p) +- path.WriteRune(filepath.Separator) ++ currentPath = nextPath + continue + } + +- // Only increment when we actually dereference a link. +- n++ ++ // It's a symlink, so get its contents and expand it by prepending it ++ // to the yet-unparsed path. ++ linksWalked++ ++ if linksWalked > maxSymlinkLimit { ++ return "", &os.PathError{Op: "SecureJoin", Path: root + string(filepath.Separator) + unsafePath, Err: syscall.ELOOP} ++ } + +- // It's a symlink, expand it by prepending it to the yet-unparsed path. +- dest, err := vfs.Readlink(fullP) ++ dest, err := vfs.Readlink(fullPath) + if err != nil { + return "", err + } ++ remainingPath = dest + string(filepath.Separator) + remainingPath + // Absolute symlinks reset any work we've already done. + if filepath.IsAbs(dest) { +- path.Reset() ++ currentPath = "" + } +- unsafePath = dest + string(filepath.Separator) + unsafePath + } + +- // We have to clean path.String() here because it may contain '..' +- // components that are entirely lexical, but would be misleading otherwise. +- // And finally do a final clean to ensure that root is also lexically +- // clean. +- fullP := filepath.Clean(string(filepath.Separator) + path.String()) +- return filepath.Clean(root + fullP), nil ++ // There should be no lexical components like ".." left in the path here, ++ // but for safety clean up the path before joining it to the root. ++ finalPath := filepath.Join(string(filepath.Separator), currentPath) ++ return filepath.Join(root, finalPath), nil + } + + // SecureJoin is a wrapper around SecureJoinVFS that just uses the os.* library +diff --git a/vendor/github.com/cyphar/filepath-securejoin/lookup_linux.go b/vendor/github.com/cyphar/filepath-securejoin/lookup_linux.go +new file mode 100644 +index 000000000000..140ac18ff503 +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/lookup_linux.go +@@ -0,0 +1,380 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "errors" ++ "fmt" ++ "os" ++ "path" ++ "path/filepath" ++ "slices" ++ "strings" ++ ++ "golang.org/x/sys/unix" ++) ++ ++type symlinkStackEntry struct { ++ // (dir, remainingPath) is what we would've returned if the link didn't ++ // exist. This matches what openat2(RESOLVE_IN_ROOT) would return in ++ // this case. ++ dir *os.File ++ remainingPath string ++ // linkUnwalked is the remaining path components from the original ++ // Readlink which we have yet to walk. When this slice is empty, we ++ // drop the link from the stack. ++ linkUnwalked []string ++} ++ ++func (se symlinkStackEntry) String() string { ++ return fmt.Sprintf("<%s>/%s [->%s]", se.dir.Name(), se.remainingPath, strings.Join(se.linkUnwalked, "/")) ++} ++ ++func (se symlinkStackEntry) Close() { ++ _ = se.dir.Close() ++} ++ ++type symlinkStack []*symlinkStackEntry ++ ++func (s symlinkStack) IsEmpty() bool { ++ return len(s) == 0 ++} ++ ++func (s *symlinkStack) Close() { ++ for _, link := range *s { ++ link.Close() ++ } ++ // TODO: Switch to clear once we switch to Go 1.21. ++ *s = nil ++} ++ ++var ( ++ errEmptyStack = errors.New("[internal] stack is empty") ++ errBrokenSymlinkStack = errors.New("[internal error] broken symlink stack") ++) ++ ++func (s *symlinkStack) popPart(part string) error { ++ if s.IsEmpty() { ++ // If there is nothing in the symlink stack, then the part was from the ++ // real path provided by the user, and this is a no-op. ++ return errEmptyStack ++ } ++ tailEntry := (*s)[len(*s)-1] ++ ++ // Double-check that we are popping the component we expect. ++ if len(tailEntry.linkUnwalked) == 0 { ++ return fmt.Errorf("%w: trying to pop component %q of empty stack entry %s", errBrokenSymlinkStack, part, tailEntry) ++ } ++ headPart := tailEntry.linkUnwalked[0] ++ if headPart != part { ++ return fmt.Errorf("%w: trying to pop component %q but the last stack entry is %s (%q)", errBrokenSymlinkStack, part, tailEntry, headPart) ++ } ++ ++ // Drop the component, but keep the entry around in case we are dealing ++ // with a "tail-chained" symlink. ++ tailEntry.linkUnwalked = tailEntry.linkUnwalked[1:] ++ return nil ++} ++ ++func (s *symlinkStack) PopPart(part string) error { ++ if err := s.popPart(part); err != nil { ++ if errors.Is(err, errEmptyStack) { ++ // Skip empty stacks. ++ err = nil ++ } ++ return err ++ } ++ ++ // Clean up any of the trailing stack entries that are empty. ++ for lastGood := len(*s) - 1; lastGood >= 0; lastGood-- { ++ entry := (*s)[lastGood] ++ if len(entry.linkUnwalked) > 0 { ++ break ++ } ++ entry.Close() ++ (*s) = (*s)[:lastGood] ++ } ++ return nil ++} ++ ++func (s *symlinkStack) push(dir *os.File, remainingPath, linkTarget string) error { ++ // Split the link target and clean up any "" parts. ++ linkTargetParts := slices.DeleteFunc( ++ strings.Split(linkTarget, "/"), ++ func(part string) bool { return part == "" }) ++ ++ // Don't add a no-op link to the stack. You can't create a no-op link ++ // symlink, but if the symlink is /, partialLookupInRoot has already jumped to the ++ // root and so there's nothing more to do. ++ if len(linkTargetParts) == 0 { ++ return nil ++ } ++ ++ // Copy the directory so the caller doesn't close our copy. ++ dirCopy, err := dupFile(dir) ++ if err != nil { ++ return err ++ } ++ ++ // Add to the stack. ++ *s = append(*s, &symlinkStackEntry{ ++ dir: dirCopy, ++ remainingPath: remainingPath, ++ linkUnwalked: linkTargetParts, ++ }) ++ return nil ++} ++ ++func (s *symlinkStack) SwapLink(linkPart string, dir *os.File, remainingPath, linkTarget string) error { ++ // If we are currently inside a symlink resolution, remove the symlink ++ // component from the last symlink entry, but don't remove the entry even ++ // if it's empty. If we are a "tail-chained" symlink (a trailing symlink we ++ // hit during a symlink resolution) we need to keep the old symlink until ++ // we finish the resolution. ++ if err := s.popPart(linkPart); err != nil { ++ if !errors.Is(err, errEmptyStack) { ++ return err ++ } ++ // Push the component regardless of whether the stack was empty. ++ } ++ return s.push(dir, remainingPath, linkTarget) ++} ++ ++func (s *symlinkStack) PopTopSymlink() (*os.File, string, bool) { ++ if s.IsEmpty() { ++ return nil, "", false ++ } ++ tailEntry := (*s)[0] ++ *s = (*s)[1:] ++ return tailEntry.dir, tailEntry.remainingPath, true ++} ++ ++// partialLookupInRoot tries to lookup as much of the request path as possible ++// within the provided root (a-la RESOLVE_IN_ROOT) and opens the final existing ++// component of the requested path, returning a file handle to the final ++// existing component and a string containing the remaining path components. ++func partialLookupInRoot(root *os.File, unsafePath string) (_ *os.File, _ string, Err error) { ++ unsafePath = filepath.ToSlash(unsafePath) // noop ++ ++ // This is very similar to SecureJoin, except that we operate on the ++ // components using file descriptors. We then return the last component we ++ // managed open, along with the remaining path components not opened. ++ ++ // Try to use openat2 if possible. ++ if hasOpenat2() { ++ return partialLookupOpenat2(root, unsafePath) ++ } ++ ++ // Get the "actual" root path from /proc/self/fd. This is necessary if the ++ // root is some magic-link like /proc/$pid/root, in which case we want to ++ // make sure when we do checkProcSelfFdPath that we are using the correct ++ // root path. ++ logicalRootPath, err := procSelfFdReadlink(root) ++ if err != nil { ++ return nil, "", fmt.Errorf("get real root path: %w", err) ++ } ++ ++ currentDir, err := dupFile(root) ++ if err != nil { ++ return nil, "", fmt.Errorf("clone root fd: %w", err) ++ } ++ defer func() { ++ if Err != nil { ++ _ = currentDir.Close() ++ } ++ }() ++ ++ // symlinkStack is used to emulate how openat2(RESOLVE_IN_ROOT) treats ++ // dangling symlinks. If we hit a non-existent path while resolving a ++ // symlink, we need to return the (dir, remainingPath) that we had when we ++ // hit the symlink (treating the symlink as though it were a regular file). ++ // The set of (dir, remainingPath) sets is stored within the symlinkStack ++ // and we add and remove parts when we hit symlink and non-symlink ++ // components respectively. We need a stack because of recursive symlinks ++ // (symlinks that contain symlink components in their target). ++ // ++ // Note that the stack is ONLY used for book-keeping. All of the actual ++ // path walking logic is still based on currentPath/remainingPath and ++ // currentDir (as in SecureJoin). ++ var symlinkStack symlinkStack ++ defer symlinkStack.Close() ++ ++ var ( ++ linksWalked int ++ currentPath string ++ remainingPath = unsafePath ++ ) ++ for remainingPath != "" { ++ // Save the current remaining path so if the part is not real we can ++ // return the path including the component. ++ oldRemainingPath := remainingPath ++ ++ // Get the next path component. ++ var part string ++ if i := strings.IndexByte(remainingPath, '/'); i == -1 { ++ part, remainingPath = remainingPath, "" ++ } else { ++ part, remainingPath = remainingPath[:i], remainingPath[i+1:] ++ } ++ // Skip any "//" components. ++ if part == "" { ++ continue ++ } ++ ++ // Apply the component lexically to the path we are building. ++ // currentPath does not contain any symlinks, and we are lexically ++ // dealing with a single component, so it's okay to do a filepath.Clean ++ // here. ++ nextPath := path.Join("/", currentPath, part) ++ // If we logically hit the root, just clone the root rather than ++ // opening the part and doing all of the other checks. ++ if nextPath == "/" { ++ if err := symlinkStack.PopPart(part); err != nil { ++ return nil, "", fmt.Errorf("walking into root with part %q failed: %w", part, err) ++ } ++ // Jump to root. ++ rootClone, err := dupFile(root) ++ if err != nil { ++ return nil, "", fmt.Errorf("clone root fd: %w", err) ++ } ++ _ = currentDir.Close() ++ currentDir = rootClone ++ currentPath = nextPath ++ continue ++ } ++ ++ // Try to open the next component. ++ nextDir, err := openatFile(currentDir, part, unix.O_PATH|unix.O_NOFOLLOW|unix.O_CLOEXEC, 0) ++ switch { ++ case err == nil: ++ st, err := nextDir.Stat() ++ if err != nil { ++ _ = nextDir.Close() ++ return nil, "", fmt.Errorf("stat component %q: %w", part, err) ++ } ++ ++ switch st.Mode() & os.ModeType { ++ case os.ModeDir: ++ // If we are dealing with a directory, simply walk into it. ++ _ = currentDir.Close() ++ currentDir = nextDir ++ currentPath = nextPath ++ ++ // The part was real, so drop it from the symlink stack. ++ if err := symlinkStack.PopPart(part); err != nil { ++ return nil, "", fmt.Errorf("walking into directory %q failed: %w", part, err) ++ } ++ ++ // If we are operating on a .., make sure we haven't escaped. ++ // We only have to check for ".." here because walking down ++ // into a regular component component cannot cause you to ++ // escape. This mirrors the logic in RESOLVE_IN_ROOT, except we ++ // have to check every ".." rather than only checking after a ++ // rename or mount on the system. ++ if part == ".." { ++ // Make sure the root hasn't moved. ++ if err := checkProcSelfFdPath(logicalRootPath, root); err != nil { ++ return nil, "", fmt.Errorf("root path moved during lookup: %w", err) ++ } ++ // Make sure the path is what we expect. ++ fullPath := logicalRootPath + nextPath ++ if err := checkProcSelfFdPath(fullPath, currentDir); err != nil { ++ return nil, "", fmt.Errorf("walking into %q had unexpected result: %w", part, err) ++ } ++ } ++ ++ case os.ModeSymlink: ++ // We don't need the handle anymore. ++ _ = nextDir.Close() ++ ++ // Unfortunately, we cannot readlink through our handle and so ++ // we need to do a separate readlinkat (which could race to ++ // give us an error if the attacker swapped the symlink with a ++ // non-symlink). ++ linkDest, err := readlinkatFile(currentDir, part) ++ if err != nil { ++ if errors.Is(err, unix.EINVAL) { ++ // The part was not a symlink, so assume that it's a ++ // regular file. It is possible for it to be a ++ // directory (if an attacker is swapping a directory ++ // and non-directory at this subpath) but erroring out ++ // here is better anyway. ++ err = fmt.Errorf("%w: path component %q is invalid: %w", errPossibleAttack, part, unix.ENOTDIR) ++ } ++ return nil, "", err ++ } ++ ++ linksWalked++ ++ if linksWalked > maxSymlinkLimit { ++ return nil, "", &os.PathError{Op: "partialLookupInRoot", Path: logicalRootPath + "/" + unsafePath, Err: unix.ELOOP} ++ } ++ ++ // Swap out the symlink's component for the link entry itself. ++ if err := symlinkStack.SwapLink(part, currentDir, oldRemainingPath, linkDest); err != nil { ++ return nil, "", fmt.Errorf("walking into symlink %q failed: push symlink: %w", part, err) ++ } ++ ++ // Update our logical remaining path. ++ remainingPath = linkDest + "/" + remainingPath ++ // Absolute symlinks reset any work we've already done. ++ if path.IsAbs(linkDest) { ++ // Jump to root. ++ rootClone, err := dupFile(root) ++ if err != nil { ++ return nil, "", fmt.Errorf("clone root fd: %w", err) ++ } ++ _ = currentDir.Close() ++ currentDir = rootClone ++ currentPath = "/" ++ } ++ default: ++ // For any other file type, we can't walk further and so we've ++ // hit the end of the lookup. The handling is very similar to ++ // ENOENT from openat(2), except that we return a handle to the ++ // component we just walked into (and we drop the component ++ // from the symlink stack). ++ _ = currentDir.Close() ++ ++ // The part existed, so drop it from the symlink stack. ++ if err := symlinkStack.PopPart(part); err != nil { ++ return nil, "", fmt.Errorf("walking into non-directory %q failed: %w", part, err) ++ } ++ ++ // If there are any remaining components in the symlink stack, ++ // we are still within a symlink resolution and thus we hit a ++ // dangling symlink. So pretend that the first symlink in the ++ // stack we hit was an ENOENT (to match openat2). ++ if oldDir, remainingPath, ok := symlinkStack.PopTopSymlink(); ok { ++ _ = nextDir.Close() ++ return oldDir, remainingPath, nil ++ } ++ ++ // The current component exists, so return it. ++ return nextDir, remainingPath, nil ++ } ++ ++ case errors.Is(err, os.ErrNotExist): ++ // If there are any remaining components in the symlink stack, we ++ // are still within a symlink resolution and thus we hit a dangling ++ // symlink. So pretend that the first symlink in the stack we hit ++ // was an ENOENT (to match openat2). ++ if oldDir, remainingPath, ok := symlinkStack.PopTopSymlink(); ok { ++ _ = currentDir.Close() ++ return oldDir, remainingPath, nil ++ } ++ // We have hit a final component that doesn't exist, so we have our ++ // partial open result. Note that we have to use the OLD remaining ++ // path, since the lookup failed. ++ return currentDir, oldRemainingPath, nil ++ ++ default: ++ return nil, "", err ++ } ++ } ++ // All of the components existed! ++ return currentDir, "", nil ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/mkdir_linux.go b/vendor/github.com/cyphar/filepath-securejoin/mkdir_linux.go +new file mode 100644 +index 000000000000..05e0bde9af4b +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/mkdir_linux.go +@@ -0,0 +1,228 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "errors" ++ "fmt" ++ "io" ++ "os" ++ "path/filepath" ++ "slices" ++ "strings" ++ ++ "golang.org/x/sys/unix" ++) ++ ++var ( ++ errInvalidMode = errors.New("invalid permission mode") ++ errPossibleAttack = errors.New("possible attack detected") ++) ++ ++// MkdirAllHandle is equivalent to MkdirAll, except that it is safer to use in ++// two respects: ++// ++// - The caller provides the root directory as an *os.File (preferably O_PATH) ++// handle. This means that the caller can be sure which root directory is ++// being used. Note that this can be emulated by using /proc/self/fd/... as ++// the root path with MkdirAll. ++// ++// - Once all of the directories have been created, an *os.File (O_PATH) handle ++// to the directory at unsafePath is returned to the caller. This is done in ++// an effectively-race-free way (an attacker would only be able to swap the ++// final directory component), which is not possible to emulate with ++// MkdirAll. ++// ++// In addition, the returned handle is obtained far more efficiently than doing ++// a brand new lookup of unsafePath (such as with SecureJoin or openat2) after ++// doing MkdirAll. If you intend to open the directory after creating it, you ++// should use MkdirAllHandle. ++func MkdirAllHandle(root *os.File, unsafePath string, mode int) (_ *os.File, Err error) { ++ // Make sure there are no os.FileMode bits set. ++ if mode&^0o7777 != 0 { ++ return nil, fmt.Errorf("%w for mkdir 0o%.3o", errInvalidMode, mode) ++ } ++ ++ // Try to open as much of the path as possible. ++ currentDir, remainingPath, err := partialLookupInRoot(root, unsafePath) ++ if err != nil { ++ return nil, fmt.Errorf("find existing subpath of %q: %w", unsafePath, err) ++ } ++ defer func() { ++ if Err != nil { ++ _ = currentDir.Close() ++ } ++ }() ++ ++ // If there is an attacker deleting directories as we walk into them, ++ // detect this proactively. Note this is guaranteed to detect if the ++ // attacker deleted any part of the tree up to currentDir. ++ // ++ // Once we walk into a dead directory, partialLookupInRoot would not be ++ // able to walk further down the tree (directories must be empty before ++ // they are deleted), and if the attacker has removed the entire tree we ++ // can be sure that anything that was originally inside a dead directory ++ // must also be deleted and thus is a dead directory in its own right. ++ // ++ // This is mostly a quality-of-life check, because mkdir will simply fail ++ // later if the attacker deletes the tree after this check. ++ if err := isDeadInode(currentDir); err != nil { ++ return nil, fmt.Errorf("finding existing subpath of %q: %w", unsafePath, err) ++ } ++ ++ // Re-open the path to match the O_DIRECTORY reopen loop later (so that we ++ // always return a non-O_PATH handle). We also check that we actually got a ++ // directory. ++ if reopenDir, err := Reopen(currentDir, unix.O_DIRECTORY|unix.O_CLOEXEC); errors.Is(err, unix.ENOTDIR) { ++ return nil, fmt.Errorf("cannot create subdirectories in %q: %w", currentDir.Name(), unix.ENOTDIR) ++ } else if err != nil { ++ return nil, fmt.Errorf("re-opening handle to %q: %w", currentDir.Name(), err) ++ } else { ++ currentDir = reopenDir ++ } ++ ++ remainingParts := strings.Split(remainingPath, string(filepath.Separator)) ++ if slices.Contains(remainingParts, "..") { ++ // The path contained ".." components after the end of the "real" ++ // components. We could try to safely resolve ".." here but that would ++ // add a bunch of extra logic for something that it's not clear even ++ // needs to be supported. So just return an error. ++ // ++ // If we do filepath.Clean(remainingPath) then we end up with the ++ // problem that ".." can erase a trailing dangling symlink and produce ++ // a path that doesn't quite match what the user asked for. ++ return nil, fmt.Errorf("%w: yet-to-be-created path %q contains '..' components", unix.ENOENT, remainingPath) ++ } ++ ++ // Make sure the mode doesn't have any type bits. ++ mode &^= unix.S_IFMT ++ // What properties do we expect any newly created directories to have? ++ var ( ++ // While umask(2) is a per-thread property, and thus this value could ++ // vary between threads, a functioning Go program would LockOSThread ++ // threads with different umasks and so we don't need to LockOSThread ++ // for this entire mkdirat loop (if we are in the locked thread with a ++ // different umask, we are already locked and there's nothing for us to ++ // do -- and if not then it doesn't matter which thread we run on and ++ // there's nothing for us to do). ++ expectedMode = uint32(unix.S_IFDIR | (mode &^ getUmask())) ++ ++ // We would want to get the fs[ug]id here, but we can't access those ++ // from userspace. In practice, nobody uses setfs[ug]id() anymore, so ++ // just use the effective [ug]id (which is equivalent to the fs[ug]id ++ // for programs that don't use setfs[ug]id). ++ expectedUid = uint32(unix.Geteuid()) ++ expectedGid = uint32(unix.Getegid()) ++ ) ++ ++ // Create the remaining components. ++ for _, part := range remainingParts { ++ switch part { ++ case "", ".": ++ // Skip over no-op paths. ++ continue ++ } ++ ++ // NOTE: mkdir(2) will not follow trailing symlinks, so we can safely ++ // create the finaly component without worrying about symlink-exchange ++ // attacks. ++ if err := unix.Mkdirat(int(currentDir.Fd()), part, uint32(mode)); err != nil { ++ err = &os.PathError{Op: "mkdirat", Path: currentDir.Name() + "/" + part, Err: err} ++ // Make the error a bit nicer if the directory is dead. ++ if err2 := isDeadInode(currentDir); err2 != nil { ++ err = fmt.Errorf("%w (%w)", err, err2) ++ } ++ return nil, err ++ } ++ ++ // Get a handle to the next component. O_DIRECTORY means we don't need ++ // to use O_PATH. ++ var nextDir *os.File ++ if hasOpenat2() { ++ nextDir, err = openat2File(currentDir, part, &unix.OpenHow{ ++ Flags: unix.O_NOFOLLOW | unix.O_DIRECTORY | unix.O_CLOEXEC, ++ Resolve: unix.RESOLVE_BENEATH | unix.RESOLVE_NO_SYMLINKS | unix.RESOLVE_NO_XDEV, ++ }) ++ } else { ++ nextDir, err = openatFile(currentDir, part, unix.O_NOFOLLOW|unix.O_DIRECTORY|unix.O_CLOEXEC, 0) ++ } ++ if err != nil { ++ return nil, err ++ } ++ _ = currentDir.Close() ++ currentDir = nextDir ++ ++ // Make sure that the directory matches what we expect. An attacker ++ // could have swapped the directory between us making it and opening ++ // it. There's no way for us to be sure that the directory is ++ // _precisely_ the same as the directory we created, but if we are in ++ // an empty directory with the same owner and mode as the one we ++ // created then there is nothing the attacker could do with this new ++ // directory that they couldn't do with the old one. ++ if stat, err := fstat(currentDir); err != nil { ++ return nil, fmt.Errorf("check newly created directory: %w", err) ++ } else { ++ if stat.Mode != expectedMode { ++ return nil, fmt.Errorf("%w: newly created directory %q has incorrect mode 0o%.3o (expected 0o%.3o)", errPossibleAttack, currentDir.Name(), stat.Mode, expectedMode) ++ } ++ if stat.Uid != expectedUid || stat.Gid != expectedGid { ++ return nil, fmt.Errorf("%w: newly created directory %q has incorrect owner %d:%d (expected %d:%d)", errPossibleAttack, currentDir.Name(), stat.Uid, stat.Gid, expectedUid, expectedGid) ++ } ++ // Check that the directory is empty. We only need to check for ++ // a single entry, and we should get EOF if the directory is ++ // empty. ++ _, err := currentDir.Readdirnames(1) ++ if !errors.Is(err, io.EOF) { ++ if err == nil { ++ err = fmt.Errorf("%w: newly created directory %q is non-empty", errPossibleAttack, currentDir.Name()) ++ } ++ return nil, fmt.Errorf("check if newly created directory %q is empty: %w", currentDir.Name(), err) ++ } ++ // Reset the offset. ++ _, _ = currentDir.Seek(0, unix.SEEK_SET) ++ } ++ } ++ return currentDir, nil ++} ++ ++// MkdirAll is a race-safe alternative to the Go stdlib's os.MkdirAll function, ++// where the new directory is guaranteed to be within the root directory (if an ++// attacker can move directories from inside the root to outside the root, the ++// created directory tree might be outside of the root but the key constraint ++// is that at no point will we walk outside of the directory tree we are ++// creating). ++// ++// Effectively, MkdirAll(root, unsafePath, mode) is equivalent to ++// ++// path, _ := securejoin.SecureJoin(root, unsafePath) ++// err := os.MkdirAll(path, mode) ++// ++// But is much safer. The above implementation is unsafe because if an attacker ++// can modify the filesystem tree between SecureJoin and MkdirAll, it is ++// possible for MkdirAll to resolve unsafe symlink components and create ++// directories outside of the root. ++// ++// If you plan to open the directory after you have created it or want to use ++// an open directory handle as the root, you should use MkdirAllHandle instead. ++// This function is a wrapper around MkdirAllHandle. ++// ++// NOTE: The mode argument must be set the unix mode bits (unix.S_I...), not ++// the Go generic mode bits (os.Mode...). ++func MkdirAll(root, unsafePath string, mode int) error { ++ rootDir, err := os.OpenFile(root, unix.O_PATH|unix.O_DIRECTORY|unix.O_CLOEXEC, 0) ++ if err != nil { ++ return err ++ } ++ defer rootDir.Close() ++ ++ f, err := MkdirAllHandle(rootDir, unsafePath, mode) ++ if err != nil { ++ return err ++ } ++ _ = f.Close() ++ return nil ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/open_linux.go b/vendor/github.com/cyphar/filepath-securejoin/open_linux.go +new file mode 100644 +index 000000000000..21700612c722 +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/open_linux.go +@@ -0,0 +1,83 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "fmt" ++ "os" ++ ++ "golang.org/x/sys/unix" ++) ++ ++// OpenatInRoot is equivalent to OpenInRoot, except that the root is provided ++// using an *os.File handle, to ensure that the correct root directory is used. ++func OpenatInRoot(root *os.File, unsafePath string) (*os.File, error) { ++ handle, remainingPath, err := partialLookupInRoot(root, unsafePath) ++ if err != nil { ++ return nil, err ++ } ++ if remainingPath != "" { ++ _ = handle.Close() ++ return nil, &os.PathError{Op: "securejoin.OpenInRoot", Path: unsafePath, Err: unix.ENOENT} ++ } ++ return handle, nil ++} ++ ++// OpenInRoot safely opens the provided unsafePath within the root. ++// Effectively, OpenInRoot(root, unsafePath) is equivalent to ++// ++// path, _ := securejoin.SecureJoin(root, unsafePath) ++// handle, err := os.OpenFile(path, unix.O_PATH|unix.O_CLOEXEC) ++// ++// But is much safer. The above implementation is unsafe because if an attacker ++// can modify the filesystem tree between SecureJoin and OpenFile, it is ++// possible for the returned file to be outside of the root. ++// ++// Note that the returned handle is an O_PATH handle, meaning that only a very ++// limited set of operations will work on the handle. This is done to avoid ++// accidentally opening an untrusted file that could cause issues (such as a ++// disconnected TTY that could cause a DoS, or some other issue). In order to ++// use the returned handle, you can "upgrade" it to a proper handle using ++// Reopen. ++func OpenInRoot(root, unsafePath string) (*os.File, error) { ++ rootDir, err := os.OpenFile(root, unix.O_PATH|unix.O_DIRECTORY|unix.O_CLOEXEC, 0) ++ if err != nil { ++ return nil, err ++ } ++ defer rootDir.Close() ++ return OpenatInRoot(rootDir, unsafePath) ++} ++ ++// Reopen takes an *os.File handle and re-opens it through /proc/self/fd. ++// Reopen(file, flags) is effectively equivalent to ++// ++// fdPath := fmt.Sprintf("/proc/self/fd/%d", file.Fd()) ++// os.OpenFile(fdPath, flags|unix.O_CLOEXEC) ++// ++// But with some extra hardenings to ensure that we are not tricked by a ++// maliciously-configured /proc mount. While this attack scenario is not ++// common, in container runtimes it is possible for higher-level runtimes to be ++// tricked into configuring an unsafe /proc that can be used to attack file ++// operations. See CVE-2019-19921 for more details. ++func Reopen(handle *os.File, flags int) (*os.File, error) { ++ procRoot, err := getProcRoot() ++ if err != nil { ++ return nil, err ++ } ++ ++ flags |= unix.O_CLOEXEC ++ fdPath := fmt.Sprintf("fd/%d", handle.Fd()) ++ return doProcSelfMagiclink(procRoot, fdPath, func(procDirHandle *os.File, base string) (*os.File, error) { ++ // Rather than just wrapping openatFile, open-code it so we can copy ++ // handle.Name(). ++ reopenFd, err := unix.Openat(int(procDirHandle.Fd()), base, flags, 0) ++ if err != nil { ++ return nil, fmt.Errorf("reopen fd %d: %w", handle.Fd(), err) ++ } ++ return os.NewFile(uintptr(reopenFd), handle.Name()), nil ++ }) ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/openat2_linux.go b/vendor/github.com/cyphar/filepath-securejoin/openat2_linux.go +new file mode 100644 +index 000000000000..fc93db8644eb +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/openat2_linux.go +@@ -0,0 +1,128 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "errors" ++ "fmt" ++ "os" ++ "path/filepath" ++ "strings" ++ "sync" ++ "testing" ++ ++ "golang.org/x/sys/unix" ++) ++ ++var ( ++ hasOpenat2Bool bool ++ hasOpenat2Once sync.Once ++ ++ testingForceHasOpenat2 *bool ++) ++ ++func hasOpenat2() bool { ++ if testing.Testing() && testingForceHasOpenat2 != nil { ++ return *testingForceHasOpenat2 ++ } ++ hasOpenat2Once.Do(func() { ++ fd, err := unix.Openat2(unix.AT_FDCWD, ".", &unix.OpenHow{ ++ Flags: unix.O_PATH | unix.O_CLOEXEC, ++ Resolve: unix.RESOLVE_NO_SYMLINKS | unix.RESOLVE_IN_ROOT, ++ }) ++ if err == nil { ++ hasOpenat2Bool = true ++ _ = unix.Close(fd) ++ } ++ }) ++ return hasOpenat2Bool ++} ++ ++func scopedLookupShouldRetry(how *unix.OpenHow, err error) bool { ++ // RESOLVE_IN_ROOT (and RESOLVE_BENEATH) can return -EAGAIN if we resolve ++ // ".." while a mount or rename occurs anywhere on the system. This could ++ // happen spuriously, or as the result of an attacker trying to mess with ++ // us during lookup. ++ // ++ // In addition, scoped lookups have a "safety check" at the end of ++ // complete_walk which will return -EXDEV if the final path is not in the ++ // root. ++ return how.Resolve&(unix.RESOLVE_IN_ROOT|unix.RESOLVE_BENEATH) != 0 && ++ (errors.Is(err, unix.EAGAIN) || errors.Is(err, unix.EXDEV)) ++} ++ ++const scopedLookupMaxRetries = 10 ++ ++func openat2File(dir *os.File, path string, how *unix.OpenHow) (*os.File, error) { ++ fullPath := dir.Name() + "/" + path ++ // Make sure we always set O_CLOEXEC. ++ how.Flags |= unix.O_CLOEXEC ++ var tries int ++ for tries < scopedLookupMaxRetries { ++ fd, err := unix.Openat2(int(dir.Fd()), path, how) ++ if err != nil { ++ if scopedLookupShouldRetry(how, err) { ++ // We retry a couple of times to avoid the spurious errors, and ++ // if we are being attacked then returning -EAGAIN is the best ++ // we can do. ++ tries++ ++ continue ++ } ++ return nil, &os.PathError{Op: "openat2", Path: fullPath, Err: err} ++ } ++ // If we are using RESOLVE_IN_ROOT, the name we generated may be wrong. ++ // NOTE: The procRoot code MUST NOT use RESOLVE_IN_ROOT, otherwise ++ // you'll get infinite recursion here. ++ if how.Resolve&unix.RESOLVE_IN_ROOT == unix.RESOLVE_IN_ROOT { ++ if actualPath, err := rawProcSelfFdReadlink(fd); err == nil { ++ fullPath = actualPath ++ } ++ } ++ return os.NewFile(uintptr(fd), fullPath), nil ++ } ++ return nil, &os.PathError{Op: "openat2", Path: fullPath, Err: errPossibleAttack} ++} ++ ++// partialLookupOpenat2 is an alternative implementation of ++// partialLookupInRoot, using openat2(RESOLVE_IN_ROOT) to more safely get a ++// handle to the deepest existing child of the requested path within the root. ++func partialLookupOpenat2(root *os.File, unsafePath string) (*os.File, string, error) { ++ // TODO: Implement this as a git-bisect-like binary search. ++ ++ unsafePath = filepath.ToSlash(unsafePath) // noop ++ endIdx := len(unsafePath) ++ for endIdx > 0 { ++ subpath := unsafePath[:endIdx] ++ ++ handle, err := openat2File(root, subpath, &unix.OpenHow{ ++ Flags: unix.O_PATH | unix.O_CLOEXEC, ++ Resolve: unix.RESOLVE_IN_ROOT | unix.RESOLVE_NO_MAGICLINKS, ++ }) ++ if err == nil { ++ // Jump over the slash if we have a non-"" remainingPath. ++ if endIdx < len(unsafePath) { ++ endIdx += 1 ++ } ++ // We found a subpath! ++ return handle, unsafePath[endIdx:], nil ++ } ++ if errors.Is(err, unix.ENOENT) || errors.Is(err, unix.ENOTDIR) { ++ // That path doesn't exist, let's try the next directory up. ++ endIdx = strings.LastIndexByte(subpath, '/') ++ continue ++ } ++ return nil, "", fmt.Errorf("open subpath: %w", err) ++ } ++ // If we couldn't open anything, the whole subpath is missing. Return a ++ // copy of the root fd so that the caller doesn't close this one by ++ // accident. ++ rootClone, err := dupFile(root) ++ if err != nil { ++ return nil, "", err ++ } ++ return rootClone, unsafePath, nil ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/openat_linux.go b/vendor/github.com/cyphar/filepath-securejoin/openat_linux.go +new file mode 100644 +index 000000000000..949fb5f2d82d +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/openat_linux.go +@@ -0,0 +1,59 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "os" ++ "path/filepath" ++ ++ "golang.org/x/sys/unix" ++) ++ ++func dupFile(f *os.File) (*os.File, error) { ++ fd, err := unix.FcntlInt(f.Fd(), unix.F_DUPFD_CLOEXEC, 0) ++ if err != nil { ++ return nil, os.NewSyscallError("fcntl(F_DUPFD_CLOEXEC)", err) ++ } ++ return os.NewFile(uintptr(fd), f.Name()), nil ++} ++ ++func openatFile(dir *os.File, path string, flags int, mode int) (*os.File, error) { ++ // Make sure we always set O_CLOEXEC. ++ flags |= unix.O_CLOEXEC ++ fd, err := unix.Openat(int(dir.Fd()), path, flags, uint32(mode)) ++ if err != nil { ++ return nil, &os.PathError{Op: "openat", Path: dir.Name() + "/" + path, Err: err} ++ } ++ // All of the paths we use with openatFile(2) are guaranteed to be ++ // lexically safe, so we can use path.Join here. ++ fullPath := filepath.Join(dir.Name(), path) ++ return os.NewFile(uintptr(fd), fullPath), nil ++} ++ ++func fstatatFile(dir *os.File, path string, flags int) (unix.Stat_t, error) { ++ var stat unix.Stat_t ++ if err := unix.Fstatat(int(dir.Fd()), path, &stat, flags); err != nil { ++ return stat, &os.PathError{Op: "fstatat", Path: dir.Name() + "/" + path, Err: err} ++ } ++ return stat, nil ++} ++ ++func readlinkatFile(dir *os.File, path string) (string, error) { ++ size := 4096 ++ for { ++ linkBuf := make([]byte, size) ++ n, err := unix.Readlinkat(int(dir.Fd()), path, linkBuf) ++ if err != nil { ++ return "", &os.PathError{Op: "readlinkat", Path: dir.Name() + "/" + path, Err: err} ++ } ++ if n != size { ++ return string(linkBuf[:n]), nil ++ } ++ // Possible truncation, resize the buffer. ++ size *= 2 ++ } ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/procfs_linux.go b/vendor/github.com/cyphar/filepath-securejoin/procfs_linux.go +new file mode 100644 +index 000000000000..daac3f061712 +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/procfs_linux.go +@@ -0,0 +1,481 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "errors" ++ "fmt" ++ "os" ++ "path/filepath" ++ "runtime" ++ "strconv" ++ "sync" ++ ++ "golang.org/x/sys/unix" ++) ++ ++func fstat(f *os.File) (unix.Stat_t, error) { ++ var stat unix.Stat_t ++ if err := unix.Fstat(int(f.Fd()), &stat); err != nil { ++ return stat, &os.PathError{Op: "fstat", Path: f.Name(), Err: err} ++ } ++ return stat, nil ++} ++ ++func fstatfs(f *os.File) (unix.Statfs_t, error) { ++ var statfs unix.Statfs_t ++ if err := unix.Fstatfs(int(f.Fd()), &statfs); err != nil { ++ return statfs, &os.PathError{Op: "fstatfs", Path: f.Name(), Err: err} ++ } ++ return statfs, nil ++} ++ ++// The kernel guarantees that the root inode of a procfs mount has an ++// f_type of PROC_SUPER_MAGIC and st_ino of PROC_ROOT_INO. ++const ( ++ procSuperMagic = 0x9fa0 // PROC_SUPER_MAGIC ++ procRootIno = 1 // PROC_ROOT_INO ++) ++ ++func verifyProcRoot(procRoot *os.File) error { ++ if statfs, err := fstatfs(procRoot); err != nil { ++ return err ++ } else if statfs.Type != procSuperMagic { ++ return fmt.Errorf("%w: incorrect procfs root filesystem type 0x%x", errUnsafeProcfs, statfs.Type) ++ } ++ if stat, err := fstat(procRoot); err != nil { ++ return err ++ } else if stat.Ino != procRootIno { ++ return fmt.Errorf("%w: incorrect procfs root inode number %d", errUnsafeProcfs, stat.Ino) ++ } ++ return nil ++} ++ ++var ( ++ hasNewMountApiBool bool ++ hasNewMountApiOnce sync.Once ++) ++ ++func hasNewMountApi() bool { ++ hasNewMountApiOnce.Do(func() { ++ // All of the pieces of the new mount API we use (fsopen, fsconfig, ++ // fsmount, open_tree) were added together in Linux 5.1[1,2], so we can ++ // just check for one of the syscalls and the others should also be ++ // available. ++ // ++ // Just try to use open_tree(2) to open a file without OPEN_TREE_CLONE. ++ // This is equivalent to openat(2), but tells us if open_tree is ++ // available (and thus all of the other basic new mount API syscalls). ++ // open_tree(2) is most light-weight syscall to test here. ++ // ++ // [1]: merge commit 400913252d09 ++ // [2]: ++ fd, err := unix.OpenTree(-int(unix.EBADF), "/", unix.OPEN_TREE_CLOEXEC) ++ if err == nil { ++ hasNewMountApiBool = true ++ _ = unix.Close(fd) ++ } ++ }) ++ return hasNewMountApiBool ++} ++ ++func fsopen(fsName string, flags int) (*os.File, error) { ++ // Make sure we always set O_CLOEXEC. ++ flags |= unix.FSOPEN_CLOEXEC ++ fd, err := unix.Fsopen(fsName, flags) ++ if err != nil { ++ return nil, os.NewSyscallError("fsopen "+fsName, err) ++ } ++ return os.NewFile(uintptr(fd), "fscontext:"+fsName), nil ++} ++ ++func fsmount(ctx *os.File, flags, mountAttrs int) (*os.File, error) { ++ // Make sure we always set O_CLOEXEC. ++ flags |= unix.FSMOUNT_CLOEXEC ++ fd, err := unix.Fsmount(int(ctx.Fd()), flags, mountAttrs) ++ if err != nil { ++ return nil, os.NewSyscallError("fsmount "+ctx.Name(), err) ++ } ++ return os.NewFile(uintptr(fd), "fsmount:"+ctx.Name()), nil ++} ++ ++func newPrivateProcMount() (*os.File, error) { ++ procfsCtx, err := fsopen("proc", unix.FSOPEN_CLOEXEC) ++ if err != nil { ++ return nil, err ++ } ++ defer procfsCtx.Close() ++ ++ // Try to configure hidepid=ptraceable,subset=pid if possible, but ignore errors. ++ _ = unix.FsconfigSetString(int(procfsCtx.Fd()), "hidepid", "ptraceable") ++ _ = unix.FsconfigSetString(int(procfsCtx.Fd()), "subset", "pid") ++ ++ // Get an actual handle. ++ if err := unix.FsconfigCreate(int(procfsCtx.Fd())); err != nil { ++ return nil, os.NewSyscallError("fsconfig create procfs", err) ++ } ++ return fsmount(procfsCtx, unix.FSMOUNT_CLOEXEC, unix.MS_RDONLY|unix.MS_NODEV|unix.MS_NOEXEC|unix.MS_NOSUID) ++} ++ ++func openTree(dir *os.File, path string, flags uint) (*os.File, error) { ++ dirFd := -int(unix.EBADF) ++ dirName := "." ++ if dir != nil { ++ dirFd = int(dir.Fd()) ++ dirName = dir.Name() ++ } ++ // Make sure we always set O_CLOEXEC. ++ flags |= unix.OPEN_TREE_CLOEXEC ++ fd, err := unix.OpenTree(dirFd, path, flags) ++ if err != nil { ++ return nil, &os.PathError{Op: "open_tree", Path: path, Err: err} ++ } ++ return os.NewFile(uintptr(fd), dirName+"/"+path), nil ++} ++ ++func clonePrivateProcMount() (_ *os.File, Err error) { ++ // Try to make a clone without using AT_RECURSIVE if we can. If this works, ++ // we can be sure there are no over-mounts and so if the root is valid then ++ // we're golden. Otherwise, we have to deal with over-mounts. ++ procfsHandle, err := openTree(nil, "/proc", unix.OPEN_TREE_CLONE) ++ if err != nil || testingForcePrivateProcRootOpenTreeAtRecursive(procfsHandle) { ++ procfsHandle, err = openTree(nil, "/proc", unix.OPEN_TREE_CLONE|unix.AT_RECURSIVE) ++ } ++ if err != nil { ++ return nil, fmt.Errorf("creating a detached procfs clone: %w", err) ++ } ++ defer func() { ++ if Err != nil { ++ _ = procfsHandle.Close() ++ } ++ }() ++ if err := verifyProcRoot(procfsHandle); err != nil { ++ return nil, err ++ } ++ return procfsHandle, nil ++} ++ ++func privateProcRoot() (*os.File, error) { ++ if !hasNewMountApi() { ++ return nil, fmt.Errorf("new mount api: %w", unix.ENOTSUP) ++ } ++ // Try to create a new procfs mount from scratch if we can. This ensures we ++ // can get a procfs mount even if /proc is fake (for whatever reason). ++ procRoot, err := newPrivateProcMount() ++ if err != nil || testingForcePrivateProcRootOpenTree(procRoot) { ++ // Try to clone /proc then... ++ procRoot, err = clonePrivateProcMount() ++ } ++ return procRoot, err ++} ++ ++var ( ++ procRootHandle *os.File ++ procRootError error ++ procRootOnce sync.Once ++ ++ errUnsafeProcfs = errors.New("unsafe procfs detected") ++) ++ ++func unsafeHostProcRoot() (_ *os.File, Err error) { ++ procRoot, err := os.OpenFile("/proc", unix.O_PATH|unix.O_NOFOLLOW|unix.O_DIRECTORY|unix.O_CLOEXEC, 0) ++ if err != nil { ++ return nil, err ++ } ++ defer func() { ++ if Err != nil { ++ _ = procRoot.Close() ++ } ++ }() ++ if err := verifyProcRoot(procRoot); err != nil { ++ return nil, err ++ } ++ return procRoot, nil ++} ++ ++func doGetProcRoot() (*os.File, error) { ++ procRoot, err := privateProcRoot() ++ if err != nil || testingForceGetProcRootUnsafe(procRoot) { ++ // Fall back to using a /proc handle if making a private mount failed. ++ // If we have openat2, at least we can avoid some kinds of over-mount ++ // attacks, but without openat2 there's not much we can do. ++ procRoot, err = unsafeHostProcRoot() ++ } ++ return procRoot, err ++} ++ ++func getProcRoot() (*os.File, error) { ++ procRootOnce.Do(func() { ++ procRootHandle, procRootError = doGetProcRoot() ++ }) ++ return procRootHandle, procRootError ++} ++ ++var ( ++ haveProcThreadSelf bool ++ haveProcThreadSelfOnce sync.Once ++) ++ ++type procThreadSelfCloser func() ++ ++// procThreadSelf returns a handle to /proc/thread-self/ (or an ++// equivalent handle on older kernels where /proc/thread-self doesn't exist). ++// Once finished with the handle, you must call the returned closer function ++// (runtime.UnlockOSThread). You must not pass the returned *os.File to other ++// Go threads or use the handle after calling the closer. ++// ++// This is similar to ProcThreadSelf from runc, but with extra hardening ++// applied and using *os.File. ++func procThreadSelf(procRoot *os.File, subpath string) (_ *os.File, _ procThreadSelfCloser, Err error) { ++ haveProcThreadSelfOnce.Do(func() { ++ // If the kernel doesn't support thread-self, it doesn't matter which ++ // /proc handle we use. ++ _, err := fstatatFile(procRoot, "thread-self", unix.AT_SYMLINK_NOFOLLOW) ++ haveProcThreadSelf = (err == nil) ++ }) ++ ++ // We need to lock our thread until the caller is done with the handle ++ // because between getting the handle and using it we could get interrupted ++ // by the Go runtime and hit the case where the underlying thread is ++ // swapped out and the original thread is killed, resulting in ++ // pull-your-hair-out-hard-to-debug issues in the caller. ++ runtime.LockOSThread() ++ defer func() { ++ if Err != nil { ++ runtime.UnlockOSThread() ++ } ++ }() ++ ++ // Figure out what prefix we want to use. ++ threadSelf := "thread-self/" ++ if !haveProcThreadSelf || testingForceProcSelfTask() { ++ /// Pre-3.17 kernels don't have /proc/thread-self, so do it manually. ++ threadSelf = "self/task/" + strconv.Itoa(unix.Gettid()) + "/" ++ if _, err := fstatatFile(procRoot, threadSelf, unix.AT_SYMLINK_NOFOLLOW); err != nil || testingForceProcSelf() { ++ // In this case, we running in a pid namespace that doesn't match ++ // the /proc mount we have. This can happen inside runc. ++ // ++ // Unfortunately, there is no nice way to get the correct TID to ++ // use here because of the age of the kernel, so we have to just ++ // use /proc/self and hope that it works. ++ threadSelf = "self/" ++ } ++ } ++ ++ // Grab the handle. ++ var ( ++ handle *os.File ++ err error ++ ) ++ if hasOpenat2() { ++ // We prefer being able to use RESOLVE_NO_XDEV if we can, to be ++ // absolutely sure we are operating on a clean /proc handle that ++ // doesn't have any cheeky overmounts that could trick us (including ++ // symlink mounts on top of /proc/thread-self). RESOLVE_BENEATH isn't ++ // stricly needed, but just use it since we have it. ++ // ++ // NOTE: /proc/self is technically a magic-link (the contents of the ++ // symlink are generated dynamically), but it doesn't use ++ // nd_jump_link() so RESOLVE_NO_MAGICLINKS allows it. ++ // ++ // NOTE: We MUST NOT use RESOLVE_IN_ROOT here, as openat2File uses ++ // procSelfFdReadlink to clean up the returned f.Name() if we use ++ // RESOLVE_IN_ROOT (which would lead to an infinite recursion). ++ handle, err = openat2File(procRoot, threadSelf+subpath, &unix.OpenHow{ ++ Flags: unix.O_PATH | unix.O_CLOEXEC, ++ Resolve: unix.RESOLVE_BENEATH | unix.RESOLVE_NO_XDEV | unix.RESOLVE_NO_MAGICLINKS, ++ }) ++ if err != nil { ++ return nil, nil, fmt.Errorf("%w: %w", errUnsafeProcfs, err) ++ } ++ } else { ++ handle, err = openatFile(procRoot, threadSelf+subpath, unix.O_PATH|unix.O_CLOEXEC, 0) ++ if err != nil { ++ return nil, nil, fmt.Errorf("%w: %w", errUnsafeProcfs, err) ++ } ++ defer func() { ++ if Err != nil { ++ _ = handle.Close() ++ } ++ }() ++ // We can't detect bind-mounts of different parts of procfs on top of ++ // /proc (a-la RESOLVE_NO_XDEV), but we can at least be sure that we ++ // aren't on the wrong filesystem here. ++ if statfs, err := fstatfs(handle); err != nil { ++ return nil, nil, err ++ } else if statfs.Type != procSuperMagic { ++ return nil, nil, fmt.Errorf("%w: incorrect /proc/self/fd filesystem type 0x%x", errUnsafeProcfs, statfs.Type) ++ } ++ } ++ return handle, runtime.UnlockOSThread, nil ++} ++ ++var ( ++ hasStatxMountIdBool bool ++ hasStatxMountIdOnce sync.Once ++) ++ ++func hasStatxMountId() bool { ++ hasStatxMountIdOnce.Do(func() { ++ var ( ++ stx unix.Statx_t ++ // We don't care which mount ID we get. The kernel will give us the ++ // unique one if it is supported. ++ wantStxMask uint32 = unix.STATX_MNT_ID_UNIQUE | unix.STATX_MNT_ID ++ ) ++ err := unix.Statx(-int(unix.EBADF), "/", 0, int(wantStxMask), &stx) ++ hasStatxMountIdBool = (err == nil && (stx.Mask&wantStxMask != 0)) ++ }) ++ return hasStatxMountIdBool ++} ++ ++func checkSymlinkOvermount(dir *os.File, path string) error { ++ // If we don't have statx(STATX_MNT_ID*) support, we can't do anything. ++ if !hasStatxMountId() { ++ return nil ++ } ++ ++ var ( ++ stx unix.Statx_t ++ // We don't care which mount ID we get. The kernel will give us the ++ // unique one if it is supported. ++ wantStxMask uint32 = unix.STATX_MNT_ID_UNIQUE | unix.STATX_MNT_ID ++ ) ++ ++ // Get the mntId of our procfs handle. ++ err := unix.Statx(int(dir.Fd()), "", unix.AT_EMPTY_PATH, int(wantStxMask), &stx) ++ if err != nil { ++ return &os.PathError{Op: "statx", Path: dir.Name(), Err: err} ++ } ++ if stx.Mask&wantStxMask == 0 { ++ // It's not a kernel limitation, for some reason we couldn't get a ++ // mount ID. Assume it's some kind of attack. ++ return fmt.Errorf("%w: could not get mnt id of dir %s", errUnsafeProcfs, dir.Name()) ++ } ++ expectedMountId := stx.Mnt_id ++ ++ // Get the mntId of the target symlink. ++ stx = unix.Statx_t{} ++ err = unix.Statx(int(dir.Fd()), path, unix.AT_SYMLINK_NOFOLLOW, int(wantStxMask), &stx) ++ if err != nil { ++ return &os.PathError{Op: "statx", Path: dir.Name() + "/" + path, Err: err} ++ } ++ if stx.Mask&wantStxMask == 0 { ++ // It's not a kernel limitation, for some reason we couldn't get a ++ // mount ID. Assume it's some kind of attack. ++ return fmt.Errorf("%w: could not get mnt id of symlink %s", errUnsafeProcfs, path) ++ } ++ gotMountId := stx.Mnt_id ++ ++ // As long as the directory mount is alive, even with wrapping mount IDs, ++ // we would expect to see a different mount ID here. (Of course, if we're ++ // using unsafeHostProcRoot() then an attaker could change this after we ++ // did this check.) ++ if expectedMountId != gotMountId { ++ return fmt.Errorf("%w: symlink %s/%s has an overmount obscuring the real link (mount ids do not match %d != %d)", errUnsafeProcfs, dir.Name(), path, expectedMountId, gotMountId) ++ } ++ return nil ++} ++ ++func doProcSelfMagiclink[T any](procRoot *os.File, subPath string, fn func(procDirHandle *os.File, base string) (T, error)) (T, error) { ++ // We cannot operate on the magic-link directly with a handle, we need to ++ // create a handle to the parent of the magic-link and then do ++ // single-component operations on it. ++ dir, base := filepath.Dir(subPath), filepath.Base(subPath) ++ ++ procDirHandle, closer, err := procThreadSelf(procRoot, dir) ++ if err != nil { ++ return *new(T), fmt.Errorf("get safe /proc/thread-self/%s handle: %w", dir, err) ++ } ++ defer procDirHandle.Close() ++ defer closer() ++ ++ // Try to detect if there is a mount on top of the symlink we are about to ++ // read. If we are using unsafeHostProcRoot(), this could change after we ++ // check it (and there's nothing we can do about that) but for ++ // privateProcRoot() this should be guaranteed to be safe (at least since ++ // Linux 5.12[1], when anonymous mount namespaces were completely isolated ++ // from external mounts including mount propagation events). ++ // ++ // [1]: Linux commit ee2e3f50629f ("mount: fix mounting of detached mounts ++ // onto targets that reside on shared mounts"). ++ if err := checkSymlinkOvermount(procDirHandle, base); err != nil { ++ return *new(T), fmt.Errorf("check safety of %s proc magiclink: %w", subPath, err) ++ } ++ return fn(procDirHandle, base) ++} ++ ++func doRawProcSelfFdReadlink(procRoot *os.File, fd int) (string, error) { ++ fdPath := fmt.Sprintf("fd/%d", fd) ++ return doProcSelfMagiclink(procRoot, fdPath, readlinkatFile) ++} ++ ++func rawProcSelfFdReadlink(fd int) (string, error) { ++ procRoot, err := getProcRoot() ++ if err != nil { ++ return "", err ++ } ++ return doRawProcSelfFdReadlink(procRoot, fd) ++} ++ ++func procSelfFdReadlink(f *os.File) (string, error) { ++ return rawProcSelfFdReadlink(int(f.Fd())) ++} ++ ++var ( ++ errPossibleBreakout = errors.New("possible breakout detected") ++ errInvalidDirectory = errors.New("wandered into deleted directory") ++ errDeletedInode = errors.New("cannot verify path of deleted inode") ++) ++ ++func isDeadInode(file *os.File) error { ++ // If the nlink of a file drops to 0, there is an attacker deleting ++ // directories during our walk, which could result in weird /proc values. ++ // It's better to error out in this case. ++ stat, err := fstat(file) ++ if err != nil { ++ return fmt.Errorf("check for dead inode: %w", err) ++ } ++ if stat.Nlink == 0 { ++ err := errDeletedInode ++ if stat.Mode&unix.S_IFMT == unix.S_IFDIR { ++ err = errInvalidDirectory ++ } ++ return fmt.Errorf("%w %q", err, file.Name()) ++ } ++ return nil ++} ++ ++func getUmask() int { ++ // umask is a per-thread property, but it is inherited by children, so we ++ // need to lock our OS thread to make sure that no other goroutine runs in ++ // this thread and no goroutines are spawned from this thread until we ++ // revert to the old umask. ++ // ++ // We could parse /proc/self/status to avoid this get-set problem, but ++ // /proc/thread-self requires LockOSThread anyway, so there's no real ++ // benefit over just using umask(2). ++ runtime.LockOSThread() ++ umask := unix.Umask(0) ++ unix.Umask(umask) ++ runtime.UnlockOSThread() ++ return umask ++} ++ ++func checkProcSelfFdPath(path string, file *os.File) error { ++ if err := isDeadInode(file); err != nil { ++ return err ++ } ++ actualPath, err := procSelfFdReadlink(file) ++ if err != nil { ++ return fmt.Errorf("get path of handle: %w", err) ++ } ++ if actualPath != path { ++ return fmt.Errorf("%w: handle path %q doesn't match expected path %q", errPossibleBreakout, actualPath, path) ++ } ++ return nil ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/testing_mocks_linux.go b/vendor/github.com/cyphar/filepath-securejoin/testing_mocks_linux.go +new file mode 100644 +index 000000000000..2a25d08e3785 +--- /dev/null ++++ b/vendor/github.com/cyphar/filepath-securejoin/testing_mocks_linux.go +@@ -0,0 +1,68 @@ ++//go:build linux ++ ++// Copyright (C) 2024 SUSE LLC. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++package securejoin ++ ++import ( ++ "os" ++ "testing" ++) ++ ++type forceGetProcRootLevel int ++ ++const ( ++ forceGetProcRootDefault forceGetProcRootLevel = iota ++ forceGetProcRootOpenTree // force open_tree() ++ forceGetProcRootOpenTreeAtRecursive // force open_tree(AT_RECURSIVE) ++ forceGetProcRootUnsafe // force open() ++) ++ ++var testingForceGetProcRoot *forceGetProcRootLevel ++ ++func testingCheckClose(check bool, f *os.File) bool { ++ if check { ++ if f != nil { ++ _ = f.Close() ++ } ++ return true ++ } ++ return false ++} ++ ++func testingForcePrivateProcRootOpenTree(f *os.File) bool { ++ return testing.Testing() && testingForceGetProcRoot != nil && ++ testingCheckClose(*testingForceGetProcRoot >= forceGetProcRootOpenTree, f) ++} ++ ++func testingForcePrivateProcRootOpenTreeAtRecursive(f *os.File) bool { ++ return testing.Testing() && testingForceGetProcRoot != nil && ++ testingCheckClose(*testingForceGetProcRoot >= forceGetProcRootOpenTreeAtRecursive, f) ++} ++ ++func testingForceGetProcRootUnsafe(f *os.File) bool { ++ return testing.Testing() && testingForceGetProcRoot != nil && ++ testingCheckClose(*testingForceGetProcRoot >= forceGetProcRootUnsafe, f) ++} ++ ++type forceProcThreadSelfLevel int ++ ++const ( ++ forceProcThreadSelfDefault forceProcThreadSelfLevel = iota ++ forceProcSelfTask ++ forceProcSelf ++) ++ ++var testingForceProcThreadSelf *forceProcThreadSelfLevel ++ ++func testingForceProcSelfTask() bool { ++ return testing.Testing() && testingForceProcThreadSelf != nil && ++ *testingForceProcThreadSelf >= forceProcSelfTask ++} ++ ++func testingForceProcSelf() bool { ++ return testing.Testing() && testingForceProcThreadSelf != nil && ++ *testingForceProcThreadSelf >= forceProcSelf ++} +diff --git a/vendor/github.com/cyphar/filepath-securejoin/vfs.go b/vendor/github.com/cyphar/filepath-securejoin/vfs.go +index a82a5eae11eb..6e27c7dd8e1f 100644 +--- a/vendor/github.com/cyphar/filepath-securejoin/vfs.go ++++ b/vendor/github.com/cyphar/filepath-securejoin/vfs.go +@@ -1,4 +1,4 @@ +-// Copyright (C) 2017 SUSE LLC. All rights reserved. ++// Copyright (C) 2017-2024 SUSE LLC. All rights reserved. + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +diff --git a/vendor/github.com/hashicorp/go-retryablehttp/client.go b/vendor/github.com/hashicorp/go-retryablehttp/client.go +index 1394fbc06723..c9edbd0595b0 100644 +--- a/vendor/github.com/hashicorp/go-retryablehttp/client.go ++++ b/vendor/github.com/hashicorp/go-retryablehttp/client.go +@@ -609,9 +609,9 @@ func (c *Client) Do(req *Request) (*http.Response, error) { + if logger != nil { + switch v := logger.(type) { + case LeveledLogger: +- v.Debug("performing request", "method", req.Method, "url", redactURL(req.URL)) ++ v.Debug("performing request", "method", req.Method, "url", req.URL) + case Logger: +- v.Printf("[DEBUG] %s %s", req.Method, redactURL(req.URL)) ++ v.Printf("[DEBUG] %s %s", req.Method, req.URL) + } + } + +@@ -666,9 +666,9 @@ func (c *Client) Do(req *Request) (*http.Response, error) { + if err != nil { + switch v := logger.(type) { + case LeveledLogger: +- v.Error("request failed", "error", err, "method", req.Method, "url", redactURL(req.URL)) ++ v.Error("request failed", "error", err, "method", req.Method, "url", req.URL) + case Logger: +- v.Printf("[ERR] %s %s request failed: %v", req.Method, redactURL(req.URL), err) ++ v.Printf("[ERR] %s %s request failed: %v", req.Method, req.URL, err) + } + } else { + // Call this here to maintain the behavior of logging all requests, +@@ -704,7 +704,7 @@ func (c *Client) Do(req *Request) (*http.Response, error) { + + wait := c.Backoff(c.RetryWaitMin, c.RetryWaitMax, i, resp) + if logger != nil { +- desc := fmt.Sprintf("%s %s", req.Method, redactURL(req.URL)) ++ desc := fmt.Sprintf("%s %s", req.Method, req.URL) + if resp != nil { + desc = fmt.Sprintf("%s (status: %d)", desc, resp.StatusCode) + } +@@ -760,11 +760,11 @@ func (c *Client) Do(req *Request) (*http.Response, error) { + // communicate why + if err == nil { + return nil, fmt.Errorf("%s %s giving up after %d attempt(s)", +- req.Method, redactURL(req.URL), attempt) ++ req.Method, req.URL, attempt) + } + + return nil, fmt.Errorf("%s %s giving up after %d attempt(s): %w", +- req.Method, redactURL(req.URL), attempt, err) ++ req.Method, req.URL, attempt, err) + } + + // Try to read the response body so we can reuse this connection. +@@ -845,17 +845,3 @@ func (c *Client) StandardClient() *http.Client { + Transport: &RoundTripper{Client: c}, + } + } +- +-// Taken from url.URL#Redacted() which was introduced in go 1.15. +-// We can switch to using it directly if we'll bump the minimum required go version. +-func redactURL(u *url.URL) string { +- if u == nil { +- return "" +- } +- +- ru := *u +- if _, has := ru.User.Password(); has { +- ru.User = url.UserPassword(ru.User.Username(), "xxxxx") +- } +- return ru.String() +-} +diff --git a/vendor/github.com/stretchr/testify/assert/assertion_compare.go b/vendor/github.com/stretchr/testify/assert/assertion_compare.go +index b774da88d86c..4d4b4aad6fe8 100644 +--- a/vendor/github.com/stretchr/testify/assert/assertion_compare.go ++++ b/vendor/github.com/stretchr/testify/assert/assertion_compare.go +@@ -28,6 +28,8 @@ var ( + uint32Type = reflect.TypeOf(uint32(1)) + uint64Type = reflect.TypeOf(uint64(1)) + ++ uintptrType = reflect.TypeOf(uintptr(1)) ++ + float32Type = reflect.TypeOf(float32(1)) + float64Type = reflect.TypeOf(float64(1)) + +@@ -308,11 +310,11 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) { + case reflect.Struct: + { + // All structs enter here. We're not interested in most types. +- if !canConvert(obj1Value, timeType) { ++ if !obj1Value.CanConvert(timeType) { + break + } + +- // time.Time can compared! ++ // time.Time can be compared! + timeObj1, ok := obj1.(time.Time) + if !ok { + timeObj1 = obj1Value.Convert(timeType).Interface().(time.Time) +@@ -328,7 +330,7 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) { + case reflect.Slice: + { + // We only care about the []byte type. +- if !canConvert(obj1Value, bytesType) { ++ if !obj1Value.CanConvert(bytesType) { + break + } + +@@ -345,6 +347,26 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) { + + return CompareType(bytes.Compare(bytesObj1, bytesObj2)), true + } ++ case reflect.Uintptr: ++ { ++ uintptrObj1, ok := obj1.(uintptr) ++ if !ok { ++ uintptrObj1 = obj1Value.Convert(uintptrType).Interface().(uintptr) ++ } ++ uintptrObj2, ok := obj2.(uintptr) ++ if !ok { ++ uintptrObj2 = obj2Value.Convert(uintptrType).Interface().(uintptr) ++ } ++ if uintptrObj1 > uintptrObj2 { ++ return compareGreater, true ++ } ++ if uintptrObj1 == uintptrObj2 { ++ return compareEqual, true ++ } ++ if uintptrObj1 < uintptrObj2 { ++ return compareLess, true ++ } ++ } + } + + return compareEqual, false +diff --git a/vendor/github.com/stretchr/testify/assert/assertion_compare_can_convert.go b/vendor/github.com/stretchr/testify/assert/assertion_compare_can_convert.go +deleted file mode 100644 +index da867903e2fa..000000000000 +--- a/vendor/github.com/stretchr/testify/assert/assertion_compare_can_convert.go ++++ /dev/null +@@ -1,16 +0,0 @@ +-//go:build go1.17 +-// +build go1.17 +- +-// TODO: once support for Go 1.16 is dropped, this file can be +-// merged/removed with assertion_compare_go1.17_test.go and +-// assertion_compare_legacy.go +- +-package assert +- +-import "reflect" +- +-// Wrapper around reflect.Value.CanConvert, for compatibility +-// reasons. +-func canConvert(value reflect.Value, to reflect.Type) bool { +- return value.CanConvert(to) +-} +diff --git a/vendor/github.com/stretchr/testify/assert/assertion_compare_legacy.go b/vendor/github.com/stretchr/testify/assert/assertion_compare_legacy.go +deleted file mode 100644 +index 1701af2a3c89..000000000000 +--- a/vendor/github.com/stretchr/testify/assert/assertion_compare_legacy.go ++++ /dev/null +@@ -1,16 +0,0 @@ +-//go:build !go1.17 +-// +build !go1.17 +- +-// TODO: once support for Go 1.16 is dropped, this file can be +-// merged/removed with assertion_compare_go1.17_test.go and +-// assertion_compare_can_convert.go +- +-package assert +- +-import "reflect" +- +-// Older versions of Go does not have the reflect.Value.CanConvert +-// method. +-func canConvert(value reflect.Value, to reflect.Type) bool { +- return false +-} +diff --git a/vendor/github.com/stretchr/testify/assert/assertion_format.go b/vendor/github.com/stretchr/testify/assert/assertion_format.go +index 84dbd6c790b9..3ddab109ad9e 100644 +--- a/vendor/github.com/stretchr/testify/assert/assertion_format.go ++++ b/vendor/github.com/stretchr/testify/assert/assertion_format.go +@@ -1,7 +1,4 @@ +-/* +-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +-* THIS FILE MUST NOT BE EDITED BY HAND +- */ ++// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT. + + package assert + +@@ -107,7 +104,7 @@ func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, + return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...) + } + +-// EqualValuesf asserts that two objects are equal or convertable to the same types ++// EqualValuesf asserts that two objects are equal or convertible to the same types + // and equal. + // + // assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted") +@@ -616,6 +613,16 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf + return NotErrorIs(t, err, target, append([]interface{}{msg}, args...)...) + } + ++// NotImplementsf asserts that an object does not implement the specified interface. ++// ++// assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted") ++func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { ++ if h, ok := t.(tHelper); ok { ++ h.Helper() ++ } ++ return NotImplements(t, interfaceObject, object, append([]interface{}{msg}, args...)...) ++} ++ + // NotNilf asserts that the specified object is not nil. + // + // assert.NotNilf(t, err, "error message %s", "formatted") +@@ -660,10 +667,12 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, + return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...) + } + +-// NotSubsetf asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubsetf asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") ++// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted") ++// assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted") + func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() +@@ -747,10 +756,11 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg + return Same(t, expected, actual, append([]interface{}{msg}, args...)...) + } + +-// Subsetf asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subsetf asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") ++// assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted") ++// assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted") + func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() +diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go +index b1d94aec53cc..a84e09bd4090 100644 +--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go ++++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go +@@ -1,7 +1,4 @@ +-/* +-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +-* THIS FILE MUST NOT BE EDITED BY HAND +- */ ++// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT. + + package assert + +@@ -189,7 +186,7 @@ func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface + return EqualExportedValuesf(a.t, expected, actual, msg, args...) + } + +-// EqualValues asserts that two objects are equal or convertable to the same types ++// EqualValues asserts that two objects are equal or convertible to the same types + // and equal. + // + // a.EqualValues(uint32(123), int32(123)) +@@ -200,7 +197,7 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn + return EqualValues(a.t, expected, actual, msgAndArgs...) + } + +-// EqualValuesf asserts that two objects are equal or convertable to the same types ++// EqualValuesf asserts that two objects are equal or convertible to the same types + // and equal. + // + // a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted") +@@ -1221,6 +1218,26 @@ func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...in + return NotErrorIsf(a.t, err, target, msg, args...) + } + ++// NotImplements asserts that an object does not implement the specified interface. ++// ++// a.NotImplements((*MyInterface)(nil), new(MyObject)) ++func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { ++ if h, ok := a.t.(tHelper); ok { ++ h.Helper() ++ } ++ return NotImplements(a.t, interfaceObject, object, msgAndArgs...) ++} ++ ++// NotImplementsf asserts that an object does not implement the specified interface. ++// ++// a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted") ++func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { ++ if h, ok := a.t.(tHelper); ok { ++ h.Helper() ++ } ++ return NotImplementsf(a.t, interfaceObject, object, msg, args...) ++} ++ + // NotNil asserts that the specified object is not nil. + // + // a.NotNil(err) +@@ -1309,10 +1326,12 @@ func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg stri + return NotSamef(a.t, expected, actual, msg, args...) + } + +-// NotSubset asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubset asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") ++// a.NotSubset([1, 3, 4], [1, 2]) ++// a.NotSubset({"x": 1, "y": 2}, {"z": 3}) + func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() +@@ -1320,10 +1339,12 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs + return NotSubset(a.t, list, subset, msgAndArgs...) + } + +-// NotSubsetf asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubsetf asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") ++// a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted") ++// a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted") + func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() +@@ -1483,10 +1504,11 @@ func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, + return Samef(a.t, expected, actual, msg, args...) + } + +-// Subset asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subset asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") ++// a.Subset([1, 2, 3], [1, 2]) ++// a.Subset({"x": 1, "y": 2}, {"x": 1}) + func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() +@@ -1494,10 +1516,11 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ... + return Subset(a.t, list, subset, msgAndArgs...) + } + +-// Subsetf asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subsetf asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") ++// a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted") ++// a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted") + func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() +diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go +index a55d1bba926c..0b7570f21c63 100644 +--- a/vendor/github.com/stretchr/testify/assert/assertions.go ++++ b/vendor/github.com/stretchr/testify/assert/assertions.go +@@ -19,7 +19,7 @@ import ( + + "github.com/davecgh/go-spew/spew" + "github.com/pmezard/go-difflib/difflib" +- yaml "gopkg.in/yaml.v3" ++ "gopkg.in/yaml.v3" + ) + + //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl" +@@ -110,7 +110,12 @@ func copyExportedFields(expected interface{}) interface{} { + return result.Interface() + + case reflect.Array, reflect.Slice: +- result := reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len()) ++ var result reflect.Value ++ if expectedKind == reflect.Array { ++ result = reflect.New(reflect.ArrayOf(expectedValue.Len(), expectedType.Elem())).Elem() ++ } else { ++ result = reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len()) ++ } + for i := 0; i < expectedValue.Len(); i++ { + index := expectedValue.Index(i) + if isNil(index) { +@@ -140,6 +145,8 @@ func copyExportedFields(expected interface{}) interface{} { + // structures. + // + // This function does no assertion of any kind. ++// ++// Deprecated: Use [EqualExportedValues] instead. + func ObjectsExportedFieldsAreEqual(expected, actual interface{}) bool { + expectedCleaned := copyExportedFields(expected) + actualCleaned := copyExportedFields(actual) +@@ -153,17 +160,40 @@ func ObjectsAreEqualValues(expected, actual interface{}) bool { + return true + } + +- actualType := reflect.TypeOf(actual) +- if actualType == nil { ++ expectedValue := reflect.ValueOf(expected) ++ actualValue := reflect.ValueOf(actual) ++ if !expectedValue.IsValid() || !actualValue.IsValid() { + return false + } +- expectedValue := reflect.ValueOf(expected) +- if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) { ++ ++ expectedType := expectedValue.Type() ++ actualType := actualValue.Type() ++ if !expectedType.ConvertibleTo(actualType) { ++ return false ++ } ++ ++ if !isNumericType(expectedType) || !isNumericType(actualType) { + // Attempt comparison after type conversion +- return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual) ++ return reflect.DeepEqual( ++ expectedValue.Convert(actualType).Interface(), actual, ++ ) + } + +- return false ++ // If BOTH values are numeric, there are chances of false positives due ++ // to overflow or underflow. So, we need to make sure to always convert ++ // the smaller type to a larger type before comparing. ++ if expectedType.Size() >= actualType.Size() { ++ return actualValue.Convert(expectedType).Interface() == expected ++ } ++ ++ return expectedValue.Convert(actualType).Interface() == actual ++} ++ ++// isNumericType returns true if the type is one of: ++// int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, ++// float32, float64, complex64, complex128 ++func isNumericType(t reflect.Type) bool { ++ return t.Kind() >= reflect.Int && t.Kind() <= reflect.Complex128 + } + + /* CallerInfo is necessary because the assert functions use the testing object +@@ -266,7 +296,7 @@ func messageFromMsgAndArgs(msgAndArgs ...interface{}) string { + + // Aligns the provided message so that all lines after the first line start at the same location as the first line. + // Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab). +-// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the ++// The longestLabelLen parameter specifies the length of the longest label in the output (required because this is the + // basis on which the alignment occurs). + func indentMessageLines(message string, longestLabelLen int) string { + outBuf := new(bytes.Buffer) +@@ -382,6 +412,25 @@ func Implements(t TestingT, interfaceObject interface{}, object interface{}, msg + return true + } + ++// NotImplements asserts that an object does not implement the specified interface. ++// ++// assert.NotImplements(t, (*MyInterface)(nil), new(MyObject)) ++func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { ++ if h, ok := t.(tHelper); ok { ++ h.Helper() ++ } ++ interfaceType := reflect.TypeOf(interfaceObject).Elem() ++ ++ if object == nil { ++ return Fail(t, fmt.Sprintf("Cannot check if nil does not implement %v", interfaceType), msgAndArgs...) ++ } ++ if reflect.TypeOf(object).Implements(interfaceType) { ++ return Fail(t, fmt.Sprintf("%T implements %v", object, interfaceType), msgAndArgs...) ++ } ++ ++ return true ++} ++ + // IsType asserts that the specified objects are of the same type. + func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { +@@ -496,7 +545,7 @@ func samePointers(first, second interface{}) bool { + // representations appropriate to be presented to the user. + // + // If the values are not of like type, the returned strings will be prefixed +-// with the type name, and the value will be enclosed in parenthesis similar ++// with the type name, and the value will be enclosed in parentheses similar + // to a type conversion in the Go grammar. + func formatUnequalValues(expected, actual interface{}) (e string, a string) { + if reflect.TypeOf(expected) != reflect.TypeOf(actual) { +@@ -523,7 +572,7 @@ func truncatingFormat(data interface{}) string { + return value + } + +-// EqualValues asserts that two objects are equal or convertable to the same types ++// EqualValues asserts that two objects are equal or convertible to the same types + // and equal. + // + // assert.EqualValues(t, uint32(123), int32(123)) +@@ -566,12 +615,19 @@ func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs .. + return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...) + } + ++ if aType.Kind() == reflect.Ptr { ++ aType = aType.Elem() ++ } ++ if bType.Kind() == reflect.Ptr { ++ bType = bType.Elem() ++ } ++ + if aType.Kind() != reflect.Struct { +- return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...) ++ return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...) + } + + if bType.Kind() != reflect.Struct { +- return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...) ++ return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...) + } + + expected = copyExportedFields(expected) +@@ -620,17 +676,6 @@ func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { + return Fail(t, "Expected value not to be nil.", msgAndArgs...) + } + +-// containsKind checks if a specified kind in the slice of kinds. +-func containsKind(kinds []reflect.Kind, kind reflect.Kind) bool { +- for i := 0; i < len(kinds); i++ { +- if kind == kinds[i] { +- return true +- } +- } +- +- return false +-} +- + // isNil checks if a specified object is nil or not, without Failing. + func isNil(object interface{}) bool { + if object == nil { +@@ -638,16 +683,13 @@ func isNil(object interface{}) bool { + } + + value := reflect.ValueOf(object) +- kind := value.Kind() +- isNilableKind := containsKind( +- []reflect.Kind{ +- reflect.Chan, reflect.Func, +- reflect.Interface, reflect.Map, +- reflect.Ptr, reflect.Slice, reflect.UnsafePointer}, +- kind) +- +- if isNilableKind && value.IsNil() { +- return true ++ switch value.Kind() { ++ case ++ reflect.Chan, reflect.Func, ++ reflect.Interface, reflect.Map, ++ reflect.Ptr, reflect.Slice, reflect.UnsafePointer: ++ ++ return value.IsNil() + } + + return false +@@ -731,16 +773,14 @@ func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { + + } + +-// getLen try to get length of object. +-// return (false, 0) if impossible. +-func getLen(x interface{}) (ok bool, length int) { ++// getLen tries to get the length of an object. ++// It returns (0, false) if impossible. ++func getLen(x interface{}) (length int, ok bool) { + v := reflect.ValueOf(x) + defer func() { +- if e := recover(); e != nil { +- ok = false +- } ++ ok = recover() == nil + }() +- return true, v.Len() ++ return v.Len(), true + } + + // Len asserts that the specified object has specific length. +@@ -751,13 +791,13 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) + if h, ok := t.(tHelper); ok { + h.Helper() + } +- ok, l := getLen(object) ++ l, ok := getLen(object) + if !ok { +- return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...) ++ return Fail(t, fmt.Sprintf("\"%v\" could not be applied builtin len()", object), msgAndArgs...) + } + + if l != length { +- return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...) ++ return Fail(t, fmt.Sprintf("\"%v\" should have %d item(s), but has %d", object, length, l), msgAndArgs...) + } + return true + } +@@ -919,10 +959,11 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) + + } + +-// Subset asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subset asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") ++// assert.Subset(t, [1, 2, 3], [1, 2]) ++// assert.Subset(t, {"x": 1, "y": 2}, {"x": 1}) + func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { + if h, ok := t.(tHelper); ok { + h.Helper() +@@ -975,10 +1016,12 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok + return true + } + +-// NotSubset asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubset asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") ++// assert.NotSubset(t, [1, 3, 4], [1, 2]) ++// assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3}) + func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { + if h, ok := t.(tHelper); ok { + h.Helper() +@@ -1439,7 +1482,7 @@ func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAnd + h.Helper() + } + if math.IsNaN(epsilon) { +- return Fail(t, "epsilon must not be NaN") ++ return Fail(t, "epsilon must not be NaN", msgAndArgs...) + } + actualEpsilon, err := calcRelativeError(expected, actual) + if err != nil { +@@ -1458,19 +1501,26 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m + if h, ok := t.(tHelper); ok { + h.Helper() + } +- if expected == nil || actual == nil || +- reflect.TypeOf(actual).Kind() != reflect.Slice || +- reflect.TypeOf(expected).Kind() != reflect.Slice { ++ ++ if expected == nil || actual == nil { + return Fail(t, "Parameters must be slice", msgAndArgs...) + } + +- actualSlice := reflect.ValueOf(actual) + expectedSlice := reflect.ValueOf(expected) ++ actualSlice := reflect.ValueOf(actual) + +- for i := 0; i < actualSlice.Len(); i++ { +- result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon) +- if !result { +- return result ++ if expectedSlice.Type().Kind() != reflect.Slice { ++ return Fail(t, "Expected value must be slice", msgAndArgs...) ++ } ++ ++ expectedLen := expectedSlice.Len() ++ if !IsType(t, expected, actual) || !Len(t, actual, expectedLen) { ++ return false ++ } ++ ++ for i := 0; i < expectedLen; i++ { ++ if !InEpsilon(t, expectedSlice.Index(i).Interface(), actualSlice.Index(i).Interface(), epsilon, "at index %d", i) { ++ return false + } + } + +@@ -1870,23 +1920,18 @@ func (c *CollectT) Errorf(format string, args ...interface{}) { + } + + // FailNow panics. +-func (c *CollectT) FailNow() { ++func (*CollectT) FailNow() { + panic("Assertion failed") + } + +-// Reset clears the collected errors. +-func (c *CollectT) Reset() { +- c.errors = nil ++// Deprecated: That was a method for internal usage that should not have been published. Now just panics. ++func (*CollectT) Reset() { ++ panic("Reset() is deprecated") + } + +-// Copy copies the collected errors to the supplied t. +-func (c *CollectT) Copy(t TestingT) { +- if tt, ok := t.(tHelper); ok { +- tt.Helper() +- } +- for _, err := range c.errors { +- t.Errorf("%v", err) +- } ++// Deprecated: That was a method for internal usage that should not have been published. Now just panics. ++func (*CollectT) Copy(TestingT) { ++ panic("Copy() is deprecated") + } + + // EventuallyWithT asserts that given condition will be met in waitFor time, +@@ -1912,8 +1957,8 @@ func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time + h.Helper() + } + +- collect := new(CollectT) +- ch := make(chan bool, 1) ++ var lastFinishedTickErrs []error ++ ch := make(chan []error, 1) + + timer := time.NewTimer(waitFor) + defer timer.Stop() +@@ -1924,19 +1969,25 @@ func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time + for tick := ticker.C; ; { + select { + case <-timer.C: +- collect.Copy(t) ++ for _, err := range lastFinishedTickErrs { ++ t.Errorf("%v", err) ++ } + return Fail(t, "Condition never satisfied", msgAndArgs...) + case <-tick: + tick = nil +- collect.Reset() + go func() { ++ collect := new(CollectT) ++ defer func() { ++ ch <- collect.errors ++ }() + condition(collect) +- ch <- len(collect.errors) == 0 + }() +- case v := <-ch: +- if v { ++ case errs := <-ch: ++ if len(errs) == 0 { + return true + } ++ // Keep the errors from the last ended condition, so that they can be copied to t if timeout is reached. ++ lastFinishedTickErrs = errs + tick = ticker.C + } + } +diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go +index d8038c28a758..861ed4b7ced0 100644 +--- a/vendor/github.com/stretchr/testify/assert/http_assertions.go ++++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go +@@ -12,7 +12,7 @@ import ( + // an error if building a new request fails. + func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) { + w := httptest.NewRecorder() +- req, err := http.NewRequest(method, url, nil) ++ req, err := http.NewRequest(method, url, http.NoBody) + if err != nil { + return -1, err + } +@@ -32,12 +32,12 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value + } + code, err := httpCode(handler, method, url, values) + if err != nil { +- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) ++ Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...) + } + + isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent + if !isSuccessCode { +- Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code)) ++ Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...) + } + + return isSuccessCode +@@ -54,12 +54,12 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu + } + code, err := httpCode(handler, method, url, values) + if err != nil { +- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) ++ Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...) + } + + isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect + if !isRedirectCode { +- Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code)) ++ Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...) + } + + return isRedirectCode +@@ -76,12 +76,12 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values + } + code, err := httpCode(handler, method, url, values) + if err != nil { +- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) ++ Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...) + } + + isErrorCode := code >= http.StatusBadRequest + if !isErrorCode { +- Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code)) ++ Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...) + } + + return isErrorCode +@@ -98,12 +98,12 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, va + } + code, err := httpCode(handler, method, url, values) + if err != nil { +- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) ++ Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...) + } + + successful := code == statuscode + if !successful { +- Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code)) ++ Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code), msgAndArgs...) + } + + return successful +@@ -113,7 +113,10 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, va + // empty string if building a new request fails. + func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string { + w := httptest.NewRecorder() +- req, err := http.NewRequest(method, url+"?"+values.Encode(), nil) ++ if len(values) > 0 { ++ url += "?" + values.Encode() ++ } ++ req, err := http.NewRequest(method, url, http.NoBody) + if err != nil { + return "" + } +@@ -135,7 +138,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, + + contains := strings.Contains(body, fmt.Sprint(str)) + if !contains { +- Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) ++ Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...) + } + + return contains +@@ -155,7 +158,7 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url strin + + contains := strings.Contains(body, fmt.Sprint(str)) + if contains { +- Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) ++ Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...) + } + + return !contains +diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go +index 63f852147675..506a82f80777 100644 +--- a/vendor/github.com/stretchr/testify/require/require.go ++++ b/vendor/github.com/stretchr/testify/require/require.go +@@ -1,7 +1,4 @@ +-/* +-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +-* THIS FILE MUST NOT BE EDITED BY HAND +- */ ++// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT. + + package require + +@@ -235,7 +232,7 @@ func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, + t.FailNow() + } + +-// EqualValues asserts that two objects are equal or convertable to the same types ++// EqualValues asserts that two objects are equal or convertible to the same types + // and equal. + // + // assert.EqualValues(t, uint32(123), int32(123)) +@@ -249,7 +246,7 @@ func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArg + t.FailNow() + } + +-// EqualValuesf asserts that two objects are equal or convertable to the same types ++// EqualValuesf asserts that two objects are equal or convertible to the same types + // and equal. + // + // assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted") +@@ -1546,6 +1543,32 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf + t.FailNow() + } + ++// NotImplements asserts that an object does not implement the specified interface. ++// ++// assert.NotImplements(t, (*MyInterface)(nil), new(MyObject)) ++func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { ++ if h, ok := t.(tHelper); ok { ++ h.Helper() ++ } ++ if assert.NotImplements(t, interfaceObject, object, msgAndArgs...) { ++ return ++ } ++ t.FailNow() ++} ++ ++// NotImplementsf asserts that an object does not implement the specified interface. ++// ++// assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted") ++func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) { ++ if h, ok := t.(tHelper); ok { ++ h.Helper() ++ } ++ if assert.NotImplementsf(t, interfaceObject, object, msg, args...) { ++ return ++ } ++ t.FailNow() ++} ++ + // NotNil asserts that the specified object is not nil. + // + // assert.NotNil(t, err) +@@ -1658,10 +1681,12 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, + t.FailNow() + } + +-// NotSubset asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubset asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") ++// assert.NotSubset(t, [1, 3, 4], [1, 2]) ++// assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3}) + func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) { + if h, ok := t.(tHelper); ok { + h.Helper() +@@ -1672,10 +1697,12 @@ func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...i + t.FailNow() + } + +-// NotSubsetf asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubsetf asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") ++// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted") ++// assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted") + func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) { + if h, ok := t.(tHelper); ok { + h.Helper() +@@ -1880,10 +1907,11 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg + t.FailNow() + } + +-// Subset asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subset asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") ++// assert.Subset(t, [1, 2, 3], [1, 2]) ++// assert.Subset(t, {"x": 1, "y": 2}, {"x": 1}) + func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) { + if h, ok := t.(tHelper); ok { + h.Helper() +@@ -1894,10 +1922,11 @@ func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...inte + t.FailNow() + } + +-// Subsetf asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subsetf asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") ++// assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted") ++// assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted") + func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) { + if h, ok := t.(tHelper); ok { + h.Helper() +diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go +index 3b5b09330a43..eee8310a5fa9 100644 +--- a/vendor/github.com/stretchr/testify/require/require_forward.go ++++ b/vendor/github.com/stretchr/testify/require/require_forward.go +@@ -1,7 +1,4 @@ +-/* +-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +-* THIS FILE MUST NOT BE EDITED BY HAND +- */ ++// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT. + + package require + +@@ -190,7 +187,7 @@ func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface + EqualExportedValuesf(a.t, expected, actual, msg, args...) + } + +-// EqualValues asserts that two objects are equal or convertable to the same types ++// EqualValues asserts that two objects are equal or convertible to the same types + // and equal. + // + // a.EqualValues(uint32(123), int32(123)) +@@ -201,7 +198,7 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn + EqualValues(a.t, expected, actual, msgAndArgs...) + } + +-// EqualValuesf asserts that two objects are equal or convertable to the same types ++// EqualValuesf asserts that two objects are equal or convertible to the same types + // and equal. + // + // a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted") +@@ -1222,6 +1219,26 @@ func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...in + NotErrorIsf(a.t, err, target, msg, args...) + } + ++// NotImplements asserts that an object does not implement the specified interface. ++// ++// a.NotImplements((*MyInterface)(nil), new(MyObject)) ++func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { ++ if h, ok := a.t.(tHelper); ok { ++ h.Helper() ++ } ++ NotImplements(a.t, interfaceObject, object, msgAndArgs...) ++} ++ ++// NotImplementsf asserts that an object does not implement the specified interface. ++// ++// a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted") ++func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) { ++ if h, ok := a.t.(tHelper); ok { ++ h.Helper() ++ } ++ NotImplementsf(a.t, interfaceObject, object, msg, args...) ++} ++ + // NotNil asserts that the specified object is not nil. + // + // a.NotNil(err) +@@ -1310,10 +1327,12 @@ func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg stri + NotSamef(a.t, expected, actual, msg, args...) + } + +-// NotSubset asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubset asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") ++// a.NotSubset([1, 3, 4], [1, 2]) ++// a.NotSubset({"x": 1, "y": 2}, {"z": 3}) + func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) { + if h, ok := a.t.(tHelper); ok { + h.Helper() +@@ -1321,10 +1340,12 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs + NotSubset(a.t, list, subset, msgAndArgs...) + } + +-// NotSubsetf asserts that the specified list(array, slice...) contains not all +-// elements given in the specified subset(array, slice...). ++// NotSubsetf asserts that the specified list(array, slice...) or map does NOT ++// contain all elements given in the specified subset list(array, slice...) or ++// map. + // +-// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") ++// a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted") ++// a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted") + func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) { + if h, ok := a.t.(tHelper); ok { + h.Helper() +@@ -1484,10 +1505,11 @@ func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, + Samef(a.t, expected, actual, msg, args...) + } + +-// Subset asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subset asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") ++// a.Subset([1, 2, 3], [1, 2]) ++// a.Subset({"x": 1, "y": 2}, {"x": 1}) + func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) { + if h, ok := a.t.(tHelper); ok { + h.Helper() +@@ -1495,10 +1517,11 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ... + Subset(a.t, list, subset, msgAndArgs...) + } + +-// Subsetf asserts that the specified list(array, slice...) contains all +-// elements given in the specified subset(array, slice...). ++// Subsetf asserts that the specified list(array, slice...) or map contains all ++// elements given in the specified subset list(array, slice...) or map. + // +-// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") ++// a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted") ++// a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted") + func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) { + if h, ok := a.t.(tHelper); ok { + h.Helper() +diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go +index 4756ad5f7951..8fa707aa4ba9 100644 +--- a/vendor/golang.org/x/sys/cpu/cpu.go ++++ b/vendor/golang.org/x/sys/cpu/cpu.go +@@ -103,6 +103,7 @@ var ARM64 struct { + HasASIMDDP bool // Advanced SIMD double precision instruction set + HasSHA512 bool // SHA512 hardware implementation + HasSVE bool // Scalable Vector Extensions ++ HasSVE2 bool // Scalable Vector Extensions 2 + HasASIMDFHM bool // Advanced SIMD multiplication FP16 to FP32 + _ CacheLinePad + } +diff --git a/vendor/golang.org/x/sys/cpu/cpu_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_arm64.go +index f3eb993bf24b..0e27a21e1f82 100644 +--- a/vendor/golang.org/x/sys/cpu/cpu_arm64.go ++++ b/vendor/golang.org/x/sys/cpu/cpu_arm64.go +@@ -28,6 +28,7 @@ func initOptions() { + {Name: "sm3", Feature: &ARM64.HasSM3}, + {Name: "sm4", Feature: &ARM64.HasSM4}, + {Name: "sve", Feature: &ARM64.HasSVE}, ++ {Name: "sve2", Feature: &ARM64.HasSVE2}, + {Name: "crc32", Feature: &ARM64.HasCRC32}, + {Name: "atomics", Feature: &ARM64.HasATOMICS}, + {Name: "asimdhp", Feature: &ARM64.HasASIMDHP}, +@@ -164,6 +165,15 @@ func parseARM64SystemRegisters(isar0, isar1, pfr0 uint64) { + switch extractBits(pfr0, 32, 35) { + case 1: + ARM64.HasSVE = true ++ ++ parseARM64SVERegister(getzfr0()) ++ } ++} ++ ++func parseARM64SVERegister(zfr0 uint64) { ++ switch extractBits(zfr0, 0, 3) { ++ case 1: ++ ARM64.HasSVE2 = true + } + } + +diff --git a/vendor/golang.org/x/sys/cpu/cpu_arm64.s b/vendor/golang.org/x/sys/cpu/cpu_arm64.s +index fcb9a3888205..22cc99844a75 100644 +--- a/vendor/golang.org/x/sys/cpu/cpu_arm64.s ++++ b/vendor/golang.org/x/sys/cpu/cpu_arm64.s +@@ -29,3 +29,11 @@ TEXT ·getpfr0(SB),NOSPLIT,$0-8 + WORD $0xd5380400 + MOVD R0, ret+0(FP) + RET ++ ++// func getzfr0() uint64 ++TEXT ·getzfr0(SB),NOSPLIT,$0-8 ++ // get SVE Feature Register 0 into x0 ++ // mrs x0, ID_AA64ZFR0_EL1 = d5380480 ++ WORD $0xd5380480 ++ MOVD R0, ret+0(FP) ++ RET +diff --git a/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go +index a8acd3e3285d..6ac6e1efb208 100644 +--- a/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go ++++ b/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go +@@ -9,3 +9,4 @@ package cpu + func getisar0() uint64 + func getisar1() uint64 + func getpfr0() uint64 ++func getzfr0() uint64 +diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go +index a968b80fa6ab..3d386d0fc218 100644 +--- a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go ++++ b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go +@@ -35,6 +35,8 @@ const ( + hwcap_SHA512 = 1 << 21 + hwcap_SVE = 1 << 22 + hwcap_ASIMDFHM = 1 << 23 ++ ++ hwcap2_SVE2 = 1 << 1 + ) + + // linuxKernelCanEmulateCPUID reports whether we're running +@@ -104,6 +106,9 @@ func doinit() { + ARM64.HasSHA512 = isSet(hwCap, hwcap_SHA512) + ARM64.HasSVE = isSet(hwCap, hwcap_SVE) + ARM64.HasASIMDFHM = isSet(hwCap, hwcap_ASIMDFHM) ++ ++ // HWCAP2 feature bits ++ ARM64.HasSVE2 = isSet(hwCap2, hwcap2_SVE2) + } + + func isSet(hwc uint, value uint) bool { +diff --git a/vendor/golang.org/x/sys/unix/aliases.go b/vendor/golang.org/x/sys/unix/aliases.go +index e7d3df4bd360..b0e419857502 100644 +--- a/vendor/golang.org/x/sys/unix/aliases.go ++++ b/vendor/golang.org/x/sys/unix/aliases.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9 ++//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos + + package unix + +diff --git a/vendor/golang.org/x/sys/unix/asm_zos_s390x.s b/vendor/golang.org/x/sys/unix/asm_zos_s390x.s +index 2f67ba86d574..813dfad7d264 100644 +--- a/vendor/golang.org/x/sys/unix/asm_zos_s390x.s ++++ b/vendor/golang.org/x/sys/unix/asm_zos_s390x.s +@@ -9,9 +9,11 @@ + #define PSALAA 1208(R0) + #define GTAB64(x) 80(x) + #define LCA64(x) 88(x) ++#define SAVSTACK_ASYNC(x) 336(x) // in the LCA + #define CAA(x) 8(x) +-#define EDCHPXV(x) 1016(x) // in the CAA +-#define SAVSTACK_ASYNC(x) 336(x) // in the LCA ++#define CEECAATHDID(x) 976(x) // in the CAA ++#define EDCHPXV(x) 1016(x) // in the CAA ++#define GOCB(x) 1104(x) // in the CAA + + // SS_*, where x=SAVSTACK_ASYNC + #define SS_LE(x) 0(x) +@@ -19,405 +21,362 @@ + #define SS_ERRNO(x) 16(x) + #define SS_ERRNOJR(x) 20(x) + +-#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6 ++// Function Descriptor Offsets ++#define __errno 0x156*16 ++#define __err2ad 0x16C*16 + +-TEXT ·clearErrno(SB),NOSPLIT,$0-0 +- BL addrerrno<>(SB) +- MOVD $0, 0(R3) ++// Call Instructions ++#define LE_CALL BYTE $0x0D; BYTE $0x76 // BL R7, R6 ++#define SVC_LOAD BYTE $0x0A; BYTE $0x08 // SVC 08 LOAD ++#define SVC_DELETE BYTE $0x0A; BYTE $0x09 // SVC 09 DELETE ++ ++DATA zosLibVec<>(SB)/8, $0 ++GLOBL zosLibVec<>(SB), NOPTR, $8 ++ ++TEXT ·initZosLibVec(SB), NOSPLIT|NOFRAME, $0-0 ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 ++ MOVD CAA(R8), R8 ++ MOVD EDCHPXV(R8), R8 ++ MOVD R8, zosLibVec<>(SB) ++ RET ++ ++TEXT ·GetZosLibVec(SB), NOSPLIT|NOFRAME, $0-0 ++ MOVD zosLibVec<>(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·clearErrno(SB), NOSPLIT, $0-0 ++ BL addrerrno<>(SB) ++ MOVD $0, 0(R3) + RET + + // Returns the address of errno in R3. +-TEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0 ++TEXT addrerrno<>(SB), NOSPLIT|NOFRAME, $0-0 + // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 + + // Get __errno FuncDesc. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- ADD $(0x156*16), R9 +- LMG 0(R9), R5, R6 ++ MOVD CAA(R8), R9 ++ MOVD EDCHPXV(R9), R9 ++ ADD $(__errno), R9 ++ LMG 0(R9), R5, R6 + + // Switch to saved LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) ++ MOVD SAVSTACK_ASYNC(R8), R9 ++ MOVD 0(R9), R4 ++ MOVD $0, 0(R9) + + // Call __errno function. + LE_CALL + NOPH + + // Switch back to Go stack. +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. ++ XOR R0, R0 // Restore R0 to $0. ++ MOVD R4, 0(R9) // Save stack pointer. + RET + +-TEXT ·syscall_syscall(SB),NOSPLIT,$0-56 +- BL runtime·entersyscall(SB) +- MOVD a1+8(FP), R1 +- MOVD a2+16(FP), R2 +- MOVD a3+24(FP), R3 ++// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64) ++TEXT ·svcCall(SB), NOSPLIT, $0 ++ BL runtime·save_g(SB) // Save g and stack pointer ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 ++ MOVD SAVSTACK_ASYNC(R8), R9 ++ MOVD R15, 0(R9) + +- // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 ++ MOVD argv+8(FP), R1 // Move function arguments into registers ++ MOVD dsa+16(FP), g ++ MOVD fnptr+0(FP), R15 + +- // Get function. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- MOVD trap+0(FP), R5 +- SLD $4, R5 +- ADD R5, R9 +- LMG 0(R9), R5, R6 ++ BYTE $0x0D // Branch to function ++ BYTE $0xEF + +- // Restore LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) ++ BL runtime·load_g(SB) // Restore g and stack pointer ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 ++ MOVD SAVSTACK_ASYNC(R8), R9 ++ MOVD 0(R9), R15 + +- // Call function. +- LE_CALL +- NOPH +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. +- +- MOVD R3, r1+32(FP) +- MOVD R0, r2+40(FP) +- MOVD R0, err+48(FP) +- MOVW R3, R4 +- CMP R4, $-1 +- BNE done +- BL addrerrno<>(SB) +- MOVWZ 0(R3), R3 +- MOVD R3, err+48(FP) +-done: +- BL runtime·exitsyscall(SB) + RET + +-TEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56 +- MOVD a1+8(FP), R1 +- MOVD a2+16(FP), R2 +- MOVD a3+24(FP), R3 +- +- // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- +- // Get function. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- MOVD trap+0(FP), R5 +- SLD $4, R5 +- ADD R5, R9 +- LMG 0(R9), R5, R6 ++// func svcLoad(name *byte) unsafe.Pointer ++TEXT ·svcLoad(SB), NOSPLIT, $0 ++ MOVD R15, R2 // Save go stack pointer ++ MOVD name+0(FP), R0 // Move SVC args into registers ++ MOVD $0x80000000, R1 ++ MOVD $0, R15 ++ SVC_LOAD ++ MOVW R15, R3 // Save return code from SVC ++ MOVD R2, R15 // Restore go stack pointer ++ CMP R3, $0 // Check SVC return code ++ BNE error ++ ++ MOVD $-2, R3 // Reset last bit of entry point to zero ++ AND R0, R3 ++ MOVD R3, ret+8(FP) // Return entry point returned by SVC ++ CMP R0, R3 // Check if last bit of entry point was set ++ BNE done ++ ++ MOVD R15, R2 // Save go stack pointer ++ MOVD $0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08) ++ SVC_DELETE ++ MOVD R2, R15 // Restore go stack pointer + +- // Restore LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) ++error: ++ MOVD $0, ret+8(FP) // Return 0 on failure + +- // Call function. +- LE_CALL +- NOPH +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. +- +- MOVD R3, r1+32(FP) +- MOVD R0, r2+40(FP) +- MOVD R0, err+48(FP) +- MOVW R3, R4 +- CMP R4, $-1 +- BNE done +- BL addrerrno<>(SB) +- MOVWZ 0(R3), R3 +- MOVD R3, err+48(FP) + done: ++ XOR R0, R0 // Reset r0 to 0 + RET + +-TEXT ·syscall_syscall6(SB),NOSPLIT,$0-80 +- BL runtime·entersyscall(SB) +- MOVD a1+8(FP), R1 +- MOVD a2+16(FP), R2 +- MOVD a3+24(FP), R3 ++// func svcUnload(name *byte, fnptr unsafe.Pointer) int64 ++TEXT ·svcUnload(SB), NOSPLIT, $0 ++ MOVD R15, R2 // Save go stack pointer ++ MOVD name+0(FP), R0 // Move SVC args into registers ++ MOVD fnptr+8(FP), R15 ++ SVC_DELETE ++ XOR R0, R0 // Reset r0 to 0 ++ MOVD R15, R1 // Save SVC return code ++ MOVD R2, R15 // Restore go stack pointer ++ MOVD R1, ret+16(FP) // Return SVC return code ++ RET + ++// func gettid() uint64 ++TEXT ·gettid(SB), NOSPLIT, $0 + // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 + +- // Get function. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- MOVD trap+0(FP), R5 +- SLD $4, R5 +- ADD R5, R9 +- LMG 0(R9), R5, R6 ++ // Get CEECAATHDID ++ MOVD CAA(R8), R9 ++ MOVD CEECAATHDID(R9), R9 ++ MOVD R9, ret+0(FP) + +- // Restore LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) +- +- // Fill in parameter list. +- MOVD a4+32(FP), R12 +- MOVD R12, (2176+24)(R4) +- MOVD a5+40(FP), R12 +- MOVD R12, (2176+32)(R4) +- MOVD a6+48(FP), R12 +- MOVD R12, (2176+40)(R4) +- +- // Call function. +- LE_CALL +- NOPH +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. +- +- MOVD R3, r1+56(FP) +- MOVD R0, r2+64(FP) +- MOVD R0, err+72(FP) +- MOVW R3, R4 +- CMP R4, $-1 +- BNE done +- BL addrerrno<>(SB) +- MOVWZ 0(R3), R3 +- MOVD R3, err+72(FP) +-done: +- BL runtime·exitsyscall(SB) + RET + +-TEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80 +- MOVD a1+8(FP), R1 +- MOVD a2+16(FP), R2 +- MOVD a3+24(FP), R3 +- +- // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- +- // Get function. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- MOVD trap+0(FP), R5 +- SLD $4, R5 +- ADD R5, R9 +- LMG 0(R9), R5, R6 ++// ++// Call LE function, if the return is -1 ++// errno and errno2 is retrieved ++// ++TEXT ·CallLeFuncWithErr(SB), NOSPLIT, $0 ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 ++ MOVD CAA(R8), R9 ++ MOVD g, GOCB(R9) + + // Restore LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) +- +- // Fill in parameter list. +- MOVD a4+32(FP), R12 +- MOVD R12, (2176+24)(R4) +- MOVD a5+40(FP), R12 +- MOVD R12, (2176+32)(R4) +- MOVD a6+48(FP), R12 +- MOVD R12, (2176+40)(R4) +- +- // Call function. +- LE_CALL ++ MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address ++ MOVD 0(R9), R4 // R4-> restore previously saved stack frame pointer ++ ++ MOVD parms_base+8(FP), R7 // R7 -> argument array ++ MOVD parms_len+16(FP), R8 // R8 number of arguments ++ ++ // arg 1 ---> R1 ++ CMP R8, $0 ++ BEQ docall ++ SUB $1, R8 ++ MOVD 0(R7), R1 ++ ++ // arg 2 ---> R2 ++ CMP R8, $0 ++ BEQ docall ++ SUB $1, R8 ++ ADD $8, R7 ++ MOVD 0(R7), R2 ++ ++ // arg 3 --> R3 ++ CMP R8, $0 ++ BEQ docall ++ SUB $1, R8 ++ ADD $8, R7 ++ MOVD 0(R7), R3 ++ ++ CMP R8, $0 ++ BEQ docall ++ MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument ++ ++repeat: ++ ADD $8, R7 ++ MOVD 0(R7), R0 // advance arg pointer by 8 byte ++ ADD $8, R6 // advance LE argument address by 8 byte ++ MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame ++ SUB $1, R8 ++ CMP R8, $0 ++ BNE repeat ++ ++docall: ++ MOVD funcdesc+0(FP), R8 // R8-> function descriptor ++ LMG 0(R8), R5, R6 ++ MOVD $0, 0(R9) // R9 address of SAVSTACK_ASYNC ++ LE_CALL // balr R7, R6 (return #1) ++ NOPH ++ MOVD R3, ret+32(FP) ++ CMP R3, $-1 // compare result to -1 ++ BNE done ++ ++ // retrieve errno and errno2 ++ MOVD zosLibVec<>(SB), R8 ++ ADD $(__errno), R8 ++ LMG 0(R8), R5, R6 ++ LE_CALL // balr R7, R6 __errno (return #3) + NOPH +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. +- +- MOVD R3, r1+56(FP) +- MOVD R0, r2+64(FP) +- MOVD R0, err+72(FP) +- MOVW R3, R4 +- CMP R4, $-1 +- BNE done +- BL ·rrno<>(SB) +- MOVWZ 0(R3), R3 +- MOVD R3, err+72(FP) ++ MOVWZ 0(R3), R3 ++ MOVD R3, err+48(FP) ++ MOVD zosLibVec<>(SB), R8 ++ ADD $(__err2ad), R8 ++ LMG 0(R8), R5, R6 ++ LE_CALL // balr R7, R6 __err2ad (return #2) ++ NOPH ++ MOVW (R3), R2 // retrieve errno2 ++ MOVD R2, errno2+40(FP) // store in return area ++ + done: ++ MOVD R4, 0(R9) // Save stack pointer. + RET + +-TEXT ·syscall_syscall9(SB),NOSPLIT,$0 +- BL runtime·entersyscall(SB) +- MOVD a1+8(FP), R1 +- MOVD a2+16(FP), R2 +- MOVD a3+24(FP), R3 +- +- // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- +- // Get function. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- MOVD trap+0(FP), R5 +- SLD $4, R5 +- ADD R5, R9 +- LMG 0(R9), R5, R6 ++// ++// Call LE function, if the return is 0 ++// errno and errno2 is retrieved ++// ++TEXT ·CallLeFuncWithPtrReturn(SB), NOSPLIT, $0 ++ MOVW PSALAA, R8 ++ MOVD LCA64(R8), R8 ++ MOVD CAA(R8), R9 ++ MOVD g, GOCB(R9) + + // Restore LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) +- +- // Fill in parameter list. +- MOVD a4+32(FP), R12 +- MOVD R12, (2176+24)(R4) +- MOVD a5+40(FP), R12 +- MOVD R12, (2176+32)(R4) +- MOVD a6+48(FP), R12 +- MOVD R12, (2176+40)(R4) +- MOVD a7+56(FP), R12 +- MOVD R12, (2176+48)(R4) +- MOVD a8+64(FP), R12 +- MOVD R12, (2176+56)(R4) +- MOVD a9+72(FP), R12 +- MOVD R12, (2176+64)(R4) +- +- // Call function. +- LE_CALL ++ MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address ++ MOVD 0(R9), R4 // R4-> restore previously saved stack frame pointer ++ ++ MOVD parms_base+8(FP), R7 // R7 -> argument array ++ MOVD parms_len+16(FP), R8 // R8 number of arguments ++ ++ // arg 1 ---> R1 ++ CMP R8, $0 ++ BEQ docall ++ SUB $1, R8 ++ MOVD 0(R7), R1 ++ ++ // arg 2 ---> R2 ++ CMP R8, $0 ++ BEQ docall ++ SUB $1, R8 ++ ADD $8, R7 ++ MOVD 0(R7), R2 ++ ++ // arg 3 --> R3 ++ CMP R8, $0 ++ BEQ docall ++ SUB $1, R8 ++ ADD $8, R7 ++ MOVD 0(R7), R3 ++ ++ CMP R8, $0 ++ BEQ docall ++ MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument ++ ++repeat: ++ ADD $8, R7 ++ MOVD 0(R7), R0 // advance arg pointer by 8 byte ++ ADD $8, R6 // advance LE argument address by 8 byte ++ MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame ++ SUB $1, R8 ++ CMP R8, $0 ++ BNE repeat ++ ++docall: ++ MOVD funcdesc+0(FP), R8 // R8-> function descriptor ++ LMG 0(R8), R5, R6 ++ MOVD $0, 0(R9) // R9 address of SAVSTACK_ASYNC ++ LE_CALL // balr R7, R6 (return #1) + NOPH +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. +- +- MOVD R3, r1+80(FP) +- MOVD R0, r2+88(FP) +- MOVD R0, err+96(FP) +- MOVW R3, R4 +- CMP R4, $-1 +- BNE done +- BL addrerrno<>(SB) +- MOVWZ 0(R3), R3 +- MOVD R3, err+96(FP) +-done: +- BL runtime·exitsyscall(SB) +- RET +- +-TEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0 +- MOVD a1+8(FP), R1 +- MOVD a2+16(FP), R2 +- MOVD a3+24(FP), R3 +- +- // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- +- // Get function. +- MOVD CAA(R8), R9 +- MOVD EDCHPXV(R9), R9 +- MOVD trap+0(FP), R5 +- SLD $4, R5 +- ADD R5, R9 +- LMG 0(R9), R5, R6 +- +- // Restore LE stack. +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R4 +- MOVD $0, 0(R9) +- +- // Fill in parameter list. +- MOVD a4+32(FP), R12 +- MOVD R12, (2176+24)(R4) +- MOVD a5+40(FP), R12 +- MOVD R12, (2176+32)(R4) +- MOVD a6+48(FP), R12 +- MOVD R12, (2176+40)(R4) +- MOVD a7+56(FP), R12 +- MOVD R12, (2176+48)(R4) +- MOVD a8+64(FP), R12 +- MOVD R12, (2176+56)(R4) +- MOVD a9+72(FP), R12 +- MOVD R12, (2176+64)(R4) +- +- // Call function. +- LE_CALL ++ MOVD R3, ret+32(FP) ++ CMP R3, $0 // compare result to 0 ++ BNE done ++ ++ // retrieve errno and errno2 ++ MOVD zosLibVec<>(SB), R8 ++ ADD $(__errno), R8 ++ LMG 0(R8), R5, R6 ++ LE_CALL // balr R7, R6 __errno (return #3) + NOPH +- XOR R0, R0 // Restore R0 to $0. +- MOVD R4, 0(R9) // Save stack pointer. +- +- MOVD R3, r1+80(FP) +- MOVD R0, r2+88(FP) +- MOVD R0, err+96(FP) +- MOVW R3, R4 +- CMP R4, $-1 +- BNE done +- BL addrerrno<>(SB) +- MOVWZ 0(R3), R3 +- MOVD R3, err+96(FP) +-done: +- RET +- +-// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64) +-TEXT ·svcCall(SB),NOSPLIT,$0 +- BL runtime·save_g(SB) // Save g and stack pointer +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD R15, 0(R9) +- +- MOVD argv+8(FP), R1 // Move function arguments into registers +- MOVD dsa+16(FP), g +- MOVD fnptr+0(FP), R15 +- +- BYTE $0x0D // Branch to function +- BYTE $0xEF +- +- BL runtime·load_g(SB) // Restore g and stack pointer +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- MOVD SAVSTACK_ASYNC(R8), R9 +- MOVD 0(R9), R15 +- +- RET +- +-// func svcLoad(name *byte) unsafe.Pointer +-TEXT ·svcLoad(SB),NOSPLIT,$0 +- MOVD R15, R2 // Save go stack pointer +- MOVD name+0(FP), R0 // Move SVC args into registers +- MOVD $0x80000000, R1 +- MOVD $0, R15 +- BYTE $0x0A // SVC 08 LOAD +- BYTE $0x08 +- MOVW R15, R3 // Save return code from SVC +- MOVD R2, R15 // Restore go stack pointer +- CMP R3, $0 // Check SVC return code +- BNE error +- +- MOVD $-2, R3 // Reset last bit of entry point to zero +- AND R0, R3 +- MOVD R3, addr+8(FP) // Return entry point returned by SVC +- CMP R0, R3 // Check if last bit of entry point was set +- BNE done +- +- MOVD R15, R2 // Save go stack pointer +- MOVD $0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08) +- BYTE $0x0A // SVC 09 DELETE +- BYTE $0x09 +- MOVD R2, R15 // Restore go stack pointer ++ MOVWZ 0(R3), R3 ++ MOVD R3, err+48(FP) ++ MOVD zosLibVec<>(SB), R8 ++ ADD $(__err2ad), R8 ++ LMG 0(R8), R5, R6 ++ LE_CALL // balr R7, R6 __err2ad (return #2) ++ NOPH ++ MOVW (R3), R2 // retrieve errno2 ++ MOVD R2, errno2+40(FP) // store in return area ++ XOR R2, R2 ++ MOVWZ R2, (R3) // clear errno2 + +-error: +- MOVD $0, addr+8(FP) // Return 0 on failure + done: +- XOR R0, R0 // Reset r0 to 0 ++ MOVD R4, 0(R9) // Save stack pointer. + RET + +-// func svcUnload(name *byte, fnptr unsafe.Pointer) int64 +-TEXT ·svcUnload(SB),NOSPLIT,$0 +- MOVD R15, R2 // Save go stack pointer +- MOVD name+0(FP), R0 // Move SVC args into registers +- MOVD addr+8(FP), R15 +- BYTE $0x0A // SVC 09 +- BYTE $0x09 +- XOR R0, R0 // Reset r0 to 0 +- MOVD R15, R1 // Save SVC return code +- MOVD R2, R15 // Restore go stack pointer +- MOVD R1, rc+0(FP) // Return SVC return code ++// ++// function to test if a pointer can be safely dereferenced (content read) ++// return 0 for succces ++// ++TEXT ·ptrtest(SB), NOSPLIT, $0-16 ++ MOVD arg+0(FP), R10 // test pointer in R10 ++ ++ // set up R2 to point to CEECAADMC ++ BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt 2,1208 ++ BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22 // llgtr 2,2 ++ BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF // nilh 2,32767 ++ BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg 2,88(2) ++ BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg 2,8(2) ++ BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68 // la 2,872(2) ++ ++ // set up R5 to point to the "shunt" path which set 1 to R3 (failure) ++ BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33 // xgr 3,3 ++ BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04 // bras 5,lbl1 ++ BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01 // lghi 3,1 ++ ++ // if r3 is not zero (failed) then branch to finish ++ BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33 // lbl1 ltgr 3,3 ++ BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08 // brc b'0111',lbl2 ++ ++ // stomic store shunt address in R5 into CEECAADMC ++ BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2) ++ ++ // now try reading from the test pointer in R10, if it fails it branches to the "lghi" instruction above ++ BYTE $0xE3; BYTE $0x9A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg 9,0(10) ++ ++ // finish here, restore 0 into CEECAADMC ++ BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99 // lbl2 xgr 9,9 ++ BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 9,0(2) ++ MOVD R3, ret+8(FP) // result in R3 + RET + +-// func gettid() uint64 +-TEXT ·gettid(SB), NOSPLIT, $0 +- // Get library control area (LCA). +- MOVW PSALAA, R8 +- MOVD LCA64(R8), R8 +- +- // Get CEECAATHDID +- MOVD CAA(R8), R9 +- MOVD 0x3D0(R9), R9 +- MOVD R9, ret+0(FP) +- ++// ++// function to test if a untptr can be loaded from a pointer ++// return 1: the 8-byte content ++// 2: 0 for success, 1 for failure ++// ++// func safeload(ptr uintptr) ( value uintptr, error uintptr) ++TEXT ·safeload(SB), NOSPLIT, $0-24 ++ MOVD ptr+0(FP), R10 // test pointer in R10 ++ MOVD $0x0, R6 ++ BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt 2,1208 ++ BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22 // llgtr 2,2 ++ BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF // nilh 2,32767 ++ BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg 2,88(2) ++ BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg 2,8(2) ++ BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68 // la 2,872(2) ++ BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33 // xgr 3,3 ++ BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04 // bras 5,lbl1 ++ BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01 // lghi 3,1 ++ BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33 // lbl1 ltgr 3,3 ++ BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08 // brc b'0111',lbl2 ++ BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2) ++ BYTE $0xE3; BYTE $0x6A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg 6,0(10) ++ BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99 // lbl2 xgr 9,9 ++ BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 9,0(2) ++ MOVD R6, value+8(FP) // result in R6 ++ MOVD R3, error+16(FP) // error in R3 + RET +diff --git a/vendor/golang.org/x/sys/unix/bpxsvc_zos.go b/vendor/golang.org/x/sys/unix/bpxsvc_zos.go +new file mode 100644 +index 000000000000..39d647d863a0 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/bpxsvc_zos.go +@@ -0,0 +1,657 @@ ++// 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. ++ ++//go:build zos ++ ++package unix ++ ++import ( ++ "bytes" ++ "fmt" ++ "unsafe" ++) ++ ++//go:noescape ++func bpxcall(plist []unsafe.Pointer, bpx_offset int64) ++ ++//go:noescape ++func A2e([]byte) ++ ++//go:noescape ++func E2a([]byte) ++ ++const ( ++ BPX4STA = 192 // stat ++ BPX4FST = 104 // fstat ++ BPX4LST = 132 // lstat ++ BPX4OPN = 156 // open ++ BPX4CLO = 72 // close ++ BPX4CHR = 500 // chattr ++ BPX4FCR = 504 // fchattr ++ BPX4LCR = 1180 // lchattr ++ BPX4CTW = 492 // cond_timed_wait ++ BPX4GTH = 1056 // __getthent ++ BPX4PTQ = 412 // pthread_quiesc ++ BPX4PTR = 320 // ptrace ++) ++ ++const ( ++ //options ++ //byte1 ++ BPX_OPNFHIGH = 0x80 ++ //byte2 ++ BPX_OPNFEXEC = 0x80 ++ //byte3 ++ BPX_O_NOLARGEFILE = 0x08 ++ BPX_O_LARGEFILE = 0x04 ++ BPX_O_ASYNCSIG = 0x02 ++ BPX_O_SYNC = 0x01 ++ //byte4 ++ BPX_O_CREXCL = 0xc0 ++ BPX_O_CREAT = 0x80 ++ BPX_O_EXCL = 0x40 ++ BPX_O_NOCTTY = 0x20 ++ BPX_O_TRUNC = 0x10 ++ BPX_O_APPEND = 0x08 ++ BPX_O_NONBLOCK = 0x04 ++ BPX_FNDELAY = 0x04 ++ BPX_O_RDWR = 0x03 ++ BPX_O_RDONLY = 0x02 ++ BPX_O_WRONLY = 0x01 ++ BPX_O_ACCMODE = 0x03 ++ BPX_O_GETFL = 0x0f ++ ++ //mode ++ // byte1 (file type) ++ BPX_FT_DIR = 1 ++ BPX_FT_CHARSPEC = 2 ++ BPX_FT_REGFILE = 3 ++ BPX_FT_FIFO = 4 ++ BPX_FT_SYMLINK = 5 ++ BPX_FT_SOCKET = 6 ++ //byte3 ++ BPX_S_ISUID = 0x08 ++ BPX_S_ISGID = 0x04 ++ BPX_S_ISVTX = 0x02 ++ BPX_S_IRWXU1 = 0x01 ++ BPX_S_IRUSR = 0x01 ++ //byte4 ++ BPX_S_IRWXU2 = 0xc0 ++ BPX_S_IWUSR = 0x80 ++ BPX_S_IXUSR = 0x40 ++ BPX_S_IRWXG = 0x38 ++ BPX_S_IRGRP = 0x20 ++ BPX_S_IWGRP = 0x10 ++ BPX_S_IXGRP = 0x08 ++ BPX_S_IRWXOX = 0x07 ++ BPX_S_IROTH = 0x04 ++ BPX_S_IWOTH = 0x02 ++ BPX_S_IXOTH = 0x01 ++ ++ CW_INTRPT = 1 ++ CW_CONDVAR = 32 ++ CW_TIMEOUT = 64 ++ ++ PGTHA_NEXT = 2 ++ PGTHA_CURRENT = 1 ++ PGTHA_FIRST = 0 ++ PGTHA_LAST = 3 ++ PGTHA_PROCESS = 0x80 ++ PGTHA_CONTTY = 0x40 ++ PGTHA_PATH = 0x20 ++ PGTHA_COMMAND = 0x10 ++ PGTHA_FILEDATA = 0x08 ++ PGTHA_THREAD = 0x04 ++ PGTHA_PTAG = 0x02 ++ PGTHA_COMMANDLONG = 0x01 ++ PGTHA_THREADFAST = 0x80 ++ PGTHA_FILEPATH = 0x40 ++ PGTHA_THDSIGMASK = 0x20 ++ // thread quiece mode ++ QUIESCE_TERM int32 = 1 ++ QUIESCE_FORCE int32 = 2 ++ QUIESCE_QUERY int32 = 3 ++ QUIESCE_FREEZE int32 = 4 ++ QUIESCE_UNFREEZE int32 = 5 ++ FREEZE_THIS_THREAD int32 = 6 ++ FREEZE_EXIT int32 = 8 ++ QUIESCE_SRB int32 = 9 ++) ++ ++type Pgtha struct { ++ Pid uint32 // 0 ++ Tid0 uint32 // 4 ++ Tid1 uint32 ++ Accesspid byte // C ++ Accesstid byte // D ++ Accessasid uint16 // E ++ Loginname [8]byte // 10 ++ Flag1 byte // 18 ++ Flag1b2 byte // 19 ++} ++ ++type Bpxystat_t struct { // DSECT BPXYSTAT ++ St_id [4]uint8 // 0 ++ St_length uint16 // 0x4 ++ St_version uint16 // 0x6 ++ St_mode uint32 // 0x8 ++ St_ino uint32 // 0xc ++ St_dev uint32 // 0x10 ++ St_nlink uint32 // 0x14 ++ St_uid uint32 // 0x18 ++ St_gid uint32 // 0x1c ++ St_size uint64 // 0x20 ++ St_atime uint32 // 0x28 ++ St_mtime uint32 // 0x2c ++ St_ctime uint32 // 0x30 ++ St_rdev uint32 // 0x34 ++ St_auditoraudit uint32 // 0x38 ++ St_useraudit uint32 // 0x3c ++ St_blksize uint32 // 0x40 ++ St_createtime uint32 // 0x44 ++ St_auditid [4]uint32 // 0x48 ++ St_res01 uint32 // 0x58 ++ Ft_ccsid uint16 // 0x5c ++ Ft_flags uint16 // 0x5e ++ St_res01a [2]uint32 // 0x60 ++ St_res02 uint32 // 0x68 ++ St_blocks uint32 // 0x6c ++ St_opaque [3]uint8 // 0x70 ++ St_visible uint8 // 0x73 ++ St_reftime uint32 // 0x74 ++ St_fid uint64 // 0x78 ++ St_filefmt uint8 // 0x80 ++ St_fspflag2 uint8 // 0x81 ++ St_res03 [2]uint8 // 0x82 ++ St_ctimemsec uint32 // 0x84 ++ St_seclabel [8]uint8 // 0x88 ++ St_res04 [4]uint8 // 0x90 ++ // end of version 1 ++ _ uint32 // 0x94 ++ St_atime64 uint64 // 0x98 ++ St_mtime64 uint64 // 0xa0 ++ St_ctime64 uint64 // 0xa8 ++ St_createtime64 uint64 // 0xb0 ++ St_reftime64 uint64 // 0xb8 ++ _ uint64 // 0xc0 ++ St_res05 [16]uint8 // 0xc8 ++ // end of version 2 ++} ++ ++type BpxFilestatus struct { ++ Oflag1 byte ++ Oflag2 byte ++ Oflag3 byte ++ Oflag4 byte ++} ++ ++type BpxMode struct { ++ Ftype byte ++ Mode1 byte ++ Mode2 byte ++ Mode3 byte ++} ++ ++// Thr attribute structure for extended attributes ++type Bpxyatt_t struct { // DSECT BPXYATT ++ Att_id [4]uint8 ++ Att_version uint16 ++ Att_res01 [2]uint8 ++ Att_setflags1 uint8 ++ Att_setflags2 uint8 ++ Att_setflags3 uint8 ++ Att_setflags4 uint8 ++ Att_mode uint32 ++ Att_uid uint32 ++ Att_gid uint32 ++ Att_opaquemask [3]uint8 ++ Att_visblmaskres uint8 ++ Att_opaque [3]uint8 ++ Att_visibleres uint8 ++ Att_size_h uint32 ++ Att_size_l uint32 ++ Att_atime uint32 ++ Att_mtime uint32 ++ Att_auditoraudit uint32 ++ Att_useraudit uint32 ++ Att_ctime uint32 ++ Att_reftime uint32 ++ // end of version 1 ++ Att_filefmt uint8 ++ Att_res02 [3]uint8 ++ Att_filetag uint32 ++ Att_res03 [8]uint8 ++ // end of version 2 ++ Att_atime64 uint64 ++ Att_mtime64 uint64 ++ Att_ctime64 uint64 ++ Att_reftime64 uint64 ++ Att_seclabel [8]uint8 ++ Att_ver3res02 [8]uint8 ++ // end of version 3 ++} ++ ++func BpxOpen(name string, options *BpxFilestatus, mode *BpxMode) (rv int32, rc int32, rn int32) { ++ if len(name) < 1024 { ++ var namebuf [1024]byte ++ sz := int32(copy(namebuf[:], name)) ++ A2e(namebuf[:sz]) ++ var parms [7]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&sz) ++ parms[1] = unsafe.Pointer(&namebuf[0]) ++ parms[2] = unsafe.Pointer(options) ++ parms[3] = unsafe.Pointer(mode) ++ parms[4] = unsafe.Pointer(&rv) ++ parms[5] = unsafe.Pointer(&rc) ++ parms[6] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4OPN) ++ return rv, rc, rn ++ } ++ return -1, -1, -1 ++} ++ ++func BpxClose(fd int32) (rv int32, rc int32, rn int32) { ++ var parms [4]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&fd) ++ parms[1] = unsafe.Pointer(&rv) ++ parms[2] = unsafe.Pointer(&rc) ++ parms[3] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4CLO) ++ return rv, rc, rn ++} ++ ++func BpxFileFStat(fd int32, st *Bpxystat_t) (rv int32, rc int32, rn int32) { ++ st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3} ++ st.St_version = 2 ++ stat_sz := uint32(unsafe.Sizeof(*st)) ++ var parms [6]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&fd) ++ parms[1] = unsafe.Pointer(&stat_sz) ++ parms[2] = unsafe.Pointer(st) ++ parms[3] = unsafe.Pointer(&rv) ++ parms[4] = unsafe.Pointer(&rc) ++ parms[5] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4FST) ++ return rv, rc, rn ++} ++ ++func BpxFileStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn int32) { ++ if len(name) < 1024 { ++ var namebuf [1024]byte ++ sz := int32(copy(namebuf[:], name)) ++ A2e(namebuf[:sz]) ++ st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3} ++ st.St_version = 2 ++ stat_sz := uint32(unsafe.Sizeof(*st)) ++ var parms [7]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&sz) ++ parms[1] = unsafe.Pointer(&namebuf[0]) ++ parms[2] = unsafe.Pointer(&stat_sz) ++ parms[3] = unsafe.Pointer(st) ++ parms[4] = unsafe.Pointer(&rv) ++ parms[5] = unsafe.Pointer(&rc) ++ parms[6] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4STA) ++ return rv, rc, rn ++ } ++ return -1, -1, -1 ++} ++ ++func BpxFileLStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn int32) { ++ if len(name) < 1024 { ++ var namebuf [1024]byte ++ sz := int32(copy(namebuf[:], name)) ++ A2e(namebuf[:sz]) ++ st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3} ++ st.St_version = 2 ++ stat_sz := uint32(unsafe.Sizeof(*st)) ++ var parms [7]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&sz) ++ parms[1] = unsafe.Pointer(&namebuf[0]) ++ parms[2] = unsafe.Pointer(&stat_sz) ++ parms[3] = unsafe.Pointer(st) ++ parms[4] = unsafe.Pointer(&rv) ++ parms[5] = unsafe.Pointer(&rc) ++ parms[6] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4LST) ++ return rv, rc, rn ++ } ++ return -1, -1, -1 ++} ++ ++func BpxChattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) { ++ if len(path) >= 1024 { ++ return -1, -1, -1 ++ } ++ var namebuf [1024]byte ++ sz := int32(copy(namebuf[:], path)) ++ A2e(namebuf[:sz]) ++ attr_sz := uint32(unsafe.Sizeof(*attr)) ++ var parms [7]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&sz) ++ parms[1] = unsafe.Pointer(&namebuf[0]) ++ parms[2] = unsafe.Pointer(&attr_sz) ++ parms[3] = unsafe.Pointer(attr) ++ parms[4] = unsafe.Pointer(&rv) ++ parms[5] = unsafe.Pointer(&rc) ++ parms[6] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4CHR) ++ return rv, rc, rn ++} ++ ++func BpxLchattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) { ++ if len(path) >= 1024 { ++ return -1, -1, -1 ++ } ++ var namebuf [1024]byte ++ sz := int32(copy(namebuf[:], path)) ++ A2e(namebuf[:sz]) ++ attr_sz := uint32(unsafe.Sizeof(*attr)) ++ var parms [7]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&sz) ++ parms[1] = unsafe.Pointer(&namebuf[0]) ++ parms[2] = unsafe.Pointer(&attr_sz) ++ parms[3] = unsafe.Pointer(attr) ++ parms[4] = unsafe.Pointer(&rv) ++ parms[5] = unsafe.Pointer(&rc) ++ parms[6] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4LCR) ++ return rv, rc, rn ++} ++ ++func BpxFchattr(fd int32, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) { ++ attr_sz := uint32(unsafe.Sizeof(*attr)) ++ var parms [6]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&fd) ++ parms[1] = unsafe.Pointer(&attr_sz) ++ parms[2] = unsafe.Pointer(attr) ++ parms[3] = unsafe.Pointer(&rv) ++ parms[4] = unsafe.Pointer(&rc) ++ parms[5] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4FCR) ++ return rv, rc, rn ++} ++ ++func BpxCondTimedWait(sec uint32, nsec uint32, events uint32, secrem *uint32, nsecrem *uint32) (rv int32, rc int32, rn int32) { ++ var parms [8]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&sec) ++ parms[1] = unsafe.Pointer(&nsec) ++ parms[2] = unsafe.Pointer(&events) ++ parms[3] = unsafe.Pointer(secrem) ++ parms[4] = unsafe.Pointer(nsecrem) ++ parms[5] = unsafe.Pointer(&rv) ++ parms[6] = unsafe.Pointer(&rc) ++ parms[7] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4CTW) ++ return rv, rc, rn ++} ++func BpxGetthent(in *Pgtha, outlen *uint32, out unsafe.Pointer) (rv int32, rc int32, rn int32) { ++ var parms [7]unsafe.Pointer ++ inlen := uint32(26) // nothing else will work. Go says Pgtha is 28-byte because of alignment, but Pgtha is "packed" and must be 26-byte ++ parms[0] = unsafe.Pointer(&inlen) ++ parms[1] = unsafe.Pointer(&in) ++ parms[2] = unsafe.Pointer(outlen) ++ parms[3] = unsafe.Pointer(&out) ++ parms[4] = unsafe.Pointer(&rv) ++ parms[5] = unsafe.Pointer(&rc) ++ parms[6] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4GTH) ++ return rv, rc, rn ++} ++func ZosJobname() (jobname string, err error) { ++ var pgtha Pgtha ++ pgtha.Pid = uint32(Getpid()) ++ pgtha.Accesspid = PGTHA_CURRENT ++ pgtha.Flag1 = PGTHA_PROCESS ++ var out [256]byte ++ var outlen uint32 ++ outlen = 256 ++ rv, rc, rn := BpxGetthent(&pgtha, &outlen, unsafe.Pointer(&out[0])) ++ if rv == 0 { ++ gthc := []byte{0x87, 0xa3, 0x88, 0x83} // 'gthc' in ebcdic ++ ix := bytes.Index(out[:], gthc) ++ if ix == -1 { ++ err = fmt.Errorf("BPX4GTH: gthc return data not found") ++ return ++ } ++ jn := out[ix+80 : ix+88] // we didn't declare Pgthc, but jobname is 8-byte at offset 80 ++ E2a(jn) ++ jobname = string(bytes.TrimRight(jn, " ")) ++ ++ } else { ++ err = fmt.Errorf("BPX4GTH: rc=%d errno=%d reason=code=0x%x", rv, rc, rn) ++ } ++ return ++} ++func Bpx4ptq(code int32, data string) (rv int32, rc int32, rn int32) { ++ var userdata [8]byte ++ var parms [5]unsafe.Pointer ++ copy(userdata[:], data+" ") ++ A2e(userdata[:]) ++ parms[0] = unsafe.Pointer(&code) ++ parms[1] = unsafe.Pointer(&userdata[0]) ++ parms[2] = unsafe.Pointer(&rv) ++ parms[3] = unsafe.Pointer(&rc) ++ parms[4] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4PTQ) ++ return rv, rc, rn ++} ++ ++const ( ++ PT_TRACE_ME = 0 // Debug this process ++ PT_READ_I = 1 // Read a full word ++ PT_READ_D = 2 // Read a full word ++ PT_READ_U = 3 // Read control info ++ PT_WRITE_I = 4 //Write a full word ++ PT_WRITE_D = 5 //Write a full word ++ PT_CONTINUE = 7 //Continue the process ++ PT_KILL = 8 //Terminate the process ++ PT_READ_GPR = 11 // Read GPR, CR, PSW ++ PT_READ_FPR = 12 // Read FPR ++ PT_READ_VR = 13 // Read VR ++ PT_WRITE_GPR = 14 // Write GPR, CR, PSW ++ PT_WRITE_FPR = 15 // Write FPR ++ PT_WRITE_VR = 16 // Write VR ++ PT_READ_BLOCK = 17 // Read storage ++ PT_WRITE_BLOCK = 19 // Write storage ++ PT_READ_GPRH = 20 // Read GPRH ++ PT_WRITE_GPRH = 21 // Write GPRH ++ PT_REGHSET = 22 // Read all GPRHs ++ PT_ATTACH = 30 // Attach to a process ++ PT_DETACH = 31 // Detach from a process ++ PT_REGSET = 32 // Read all GPRs ++ PT_REATTACH = 33 // Reattach to a process ++ PT_LDINFO = 34 // Read loader info ++ PT_MULTI = 35 // Multi process mode ++ PT_LD64INFO = 36 // RMODE64 Info Area ++ PT_BLOCKREQ = 40 // Block request ++ PT_THREAD_INFO = 60 // Read thread info ++ PT_THREAD_MODIFY = 61 ++ PT_THREAD_READ_FOCUS = 62 ++ PT_THREAD_WRITE_FOCUS = 63 ++ PT_THREAD_HOLD = 64 ++ PT_THREAD_SIGNAL = 65 ++ PT_EXPLAIN = 66 ++ PT_EVENTS = 67 ++ PT_THREAD_INFO_EXTENDED = 68 ++ PT_REATTACH2 = 71 ++ PT_CAPTURE = 72 ++ PT_UNCAPTURE = 73 ++ PT_GET_THREAD_TCB = 74 ++ PT_GET_ALET = 75 ++ PT_SWAPIN = 76 ++ PT_EXTENDED_EVENT = 98 ++ PT_RECOVER = 99 // Debug a program check ++ PT_GPR0 = 0 // General purpose register 0 ++ PT_GPR1 = 1 // General purpose register 1 ++ PT_GPR2 = 2 // General purpose register 2 ++ PT_GPR3 = 3 // General purpose register 3 ++ PT_GPR4 = 4 // General purpose register 4 ++ PT_GPR5 = 5 // General purpose register 5 ++ PT_GPR6 = 6 // General purpose register 6 ++ PT_GPR7 = 7 // General purpose register 7 ++ PT_GPR8 = 8 // General purpose register 8 ++ PT_GPR9 = 9 // General purpose register 9 ++ PT_GPR10 = 10 // General purpose register 10 ++ PT_GPR11 = 11 // General purpose register 11 ++ PT_GPR12 = 12 // General purpose register 12 ++ PT_GPR13 = 13 // General purpose register 13 ++ PT_GPR14 = 14 // General purpose register 14 ++ PT_GPR15 = 15 // General purpose register 15 ++ PT_FPR0 = 16 // Floating point register 0 ++ PT_FPR1 = 17 // Floating point register 1 ++ PT_FPR2 = 18 // Floating point register 2 ++ PT_FPR3 = 19 // Floating point register 3 ++ PT_FPR4 = 20 // Floating point register 4 ++ PT_FPR5 = 21 // Floating point register 5 ++ PT_FPR6 = 22 // Floating point register 6 ++ PT_FPR7 = 23 // Floating point register 7 ++ PT_FPR8 = 24 // Floating point register 8 ++ PT_FPR9 = 25 // Floating point register 9 ++ PT_FPR10 = 26 // Floating point register 10 ++ PT_FPR11 = 27 // Floating point register 11 ++ PT_FPR12 = 28 // Floating point register 12 ++ PT_FPR13 = 29 // Floating point register 13 ++ PT_FPR14 = 30 // Floating point register 14 ++ PT_FPR15 = 31 // Floating point register 15 ++ PT_FPC = 32 // Floating point control register ++ PT_PSW = 40 // PSW ++ PT_PSW0 = 40 // Left half of the PSW ++ PT_PSW1 = 41 // Right half of the PSW ++ PT_CR0 = 42 // Control register 0 ++ PT_CR1 = 43 // Control register 1 ++ PT_CR2 = 44 // Control register 2 ++ PT_CR3 = 45 // Control register 3 ++ PT_CR4 = 46 // Control register 4 ++ PT_CR5 = 47 // Control register 5 ++ PT_CR6 = 48 // Control register 6 ++ PT_CR7 = 49 // Control register 7 ++ PT_CR8 = 50 // Control register 8 ++ PT_CR9 = 51 // Control register 9 ++ PT_CR10 = 52 // Control register 10 ++ PT_CR11 = 53 // Control register 11 ++ PT_CR12 = 54 // Control register 12 ++ PT_CR13 = 55 // Control register 13 ++ PT_CR14 = 56 // Control register 14 ++ PT_CR15 = 57 // Control register 15 ++ PT_GPRH0 = 58 // GP High register 0 ++ PT_GPRH1 = 59 // GP High register 1 ++ PT_GPRH2 = 60 // GP High register 2 ++ PT_GPRH3 = 61 // GP High register 3 ++ PT_GPRH4 = 62 // GP High register 4 ++ PT_GPRH5 = 63 // GP High register 5 ++ PT_GPRH6 = 64 // GP High register 6 ++ PT_GPRH7 = 65 // GP High register 7 ++ PT_GPRH8 = 66 // GP High register 8 ++ PT_GPRH9 = 67 // GP High register 9 ++ PT_GPRH10 = 68 // GP High register 10 ++ PT_GPRH11 = 69 // GP High register 11 ++ PT_GPRH12 = 70 // GP High register 12 ++ PT_GPRH13 = 71 // GP High register 13 ++ PT_GPRH14 = 72 // GP High register 14 ++ PT_GPRH15 = 73 // GP High register 15 ++ PT_VR0 = 74 // Vector register 0 ++ PT_VR1 = 75 // Vector register 1 ++ PT_VR2 = 76 // Vector register 2 ++ PT_VR3 = 77 // Vector register 3 ++ PT_VR4 = 78 // Vector register 4 ++ PT_VR5 = 79 // Vector register 5 ++ PT_VR6 = 80 // Vector register 6 ++ PT_VR7 = 81 // Vector register 7 ++ PT_VR8 = 82 // Vector register 8 ++ PT_VR9 = 83 // Vector register 9 ++ PT_VR10 = 84 // Vector register 10 ++ PT_VR11 = 85 // Vector register 11 ++ PT_VR12 = 86 // Vector register 12 ++ PT_VR13 = 87 // Vector register 13 ++ PT_VR14 = 88 // Vector register 14 ++ PT_VR15 = 89 // Vector register 15 ++ PT_VR16 = 90 // Vector register 16 ++ PT_VR17 = 91 // Vector register 17 ++ PT_VR18 = 92 // Vector register 18 ++ PT_VR19 = 93 // Vector register 19 ++ PT_VR20 = 94 // Vector register 20 ++ PT_VR21 = 95 // Vector register 21 ++ PT_VR22 = 96 // Vector register 22 ++ PT_VR23 = 97 // Vector register 23 ++ PT_VR24 = 98 // Vector register 24 ++ PT_VR25 = 99 // Vector register 25 ++ PT_VR26 = 100 // Vector register 26 ++ PT_VR27 = 101 // Vector register 27 ++ PT_VR28 = 102 // Vector register 28 ++ PT_VR29 = 103 // Vector register 29 ++ PT_VR30 = 104 // Vector register 30 ++ PT_VR31 = 105 // Vector register 31 ++ PT_PSWG = 106 // PSWG ++ PT_PSWG0 = 106 // Bytes 0-3 ++ PT_PSWG1 = 107 // Bytes 4-7 ++ PT_PSWG2 = 108 // Bytes 8-11 (IA high word) ++ PT_PSWG3 = 109 // Bytes 12-15 (IA low word) ++) ++ ++func Bpx4ptr(request int32, pid int32, addr unsafe.Pointer, data unsafe.Pointer, buffer unsafe.Pointer) (rv int32, rc int32, rn int32) { ++ var parms [8]unsafe.Pointer ++ parms[0] = unsafe.Pointer(&request) ++ parms[1] = unsafe.Pointer(&pid) ++ parms[2] = unsafe.Pointer(&addr) ++ parms[3] = unsafe.Pointer(&data) ++ parms[4] = unsafe.Pointer(&buffer) ++ parms[5] = unsafe.Pointer(&rv) ++ parms[6] = unsafe.Pointer(&rc) ++ parms[7] = unsafe.Pointer(&rn) ++ bpxcall(parms[:], BPX4PTR) ++ return rv, rc, rn ++} ++ ++func copyU8(val uint8, dest []uint8) int { ++ if len(dest) < 1 { ++ return 0 ++ } ++ dest[0] = val ++ return 1 ++} ++ ++func copyU8Arr(src, dest []uint8) int { ++ if len(dest) < len(src) { ++ return 0 ++ } ++ for i, v := range src { ++ dest[i] = v ++ } ++ return len(src) ++} ++ ++func copyU16(val uint16, dest []uint16) int { ++ if len(dest) < 1 { ++ return 0 ++ } ++ dest[0] = val ++ return 1 ++} ++ ++func copyU32(val uint32, dest []uint32) int { ++ if len(dest) < 1 { ++ return 0 ++ } ++ dest[0] = val ++ return 1 ++} ++ ++func copyU32Arr(src, dest []uint32) int { ++ if len(dest) < len(src) { ++ return 0 ++ } ++ for i, v := range src { ++ dest[i] = v ++ } ++ return len(src) ++} ++ ++func copyU64(val uint64, dest []uint64) int { ++ if len(dest) < 1 { ++ return 0 ++ } ++ dest[0] = val ++ return 1 ++} +diff --git a/vendor/golang.org/x/sys/unix/bpxsvc_zos.s b/vendor/golang.org/x/sys/unix/bpxsvc_zos.s +new file mode 100644 +index 000000000000..4bd4a179821b +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/bpxsvc_zos.s +@@ -0,0 +1,192 @@ ++// 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 "go_asm.h" ++#include "textflag.h" ++ ++// function to call USS assembly language services ++// ++// doc: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_3.1.0/com.ibm.zos.v3r1.bpxb100/bit64env.htm ++// ++// arg1 unsafe.Pointer array that ressembles an OS PLIST ++// ++// arg2 function offset as in ++// doc: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_3.1.0/com.ibm.zos.v3r1.bpxb100/bpx2cr_List_of_offsets.htm ++// ++// func bpxcall(plist []unsafe.Pointer, bpx_offset int64) ++ ++TEXT ·bpxcall(SB), NOSPLIT|NOFRAME, $0 ++ MOVD plist_base+0(FP), R1 // r1 points to plist ++ MOVD bpx_offset+24(FP), R2 // r2 offset to BPX vector table ++ MOVD R14, R7 // save r14 ++ MOVD R15, R8 // save r15 ++ MOVWZ 16(R0), R9 ++ MOVWZ 544(R9), R9 ++ MOVWZ 24(R9), R9 // call vector in r9 ++ ADD R2, R9 // add offset to vector table ++ MOVWZ (R9), R9 // r9 points to entry point ++ BYTE $0x0D // BL R14,R9 --> basr r14,r9 ++ BYTE $0xE9 // clobbers 0,1,14,15 ++ MOVD R8, R15 // restore 15 ++ JMP R7 // return via saved return address ++ ++// func A2e(arr [] byte) ++// code page conversion from 819 to 1047 ++TEXT ·A2e(SB), NOSPLIT|NOFRAME, $0 ++ MOVD arg_base+0(FP), R2 // pointer to arry of characters ++ MOVD arg_len+8(FP), R3 // count ++ XOR R0, R0 ++ XOR R1, R1 ++ BYTE $0xA7; BYTE $0x15; BYTE $0x00; BYTE $0x82 // BRAS 1,(2+(256/2)) ++ ++ // ASCII -> EBCDIC conversion table: ++ BYTE $0x00; BYTE $0x01; BYTE $0x02; BYTE $0x03 ++ BYTE $0x37; BYTE $0x2d; BYTE $0x2e; BYTE $0x2f ++ BYTE $0x16; BYTE $0x05; BYTE $0x15; BYTE $0x0b ++ BYTE $0x0c; BYTE $0x0d; BYTE $0x0e; BYTE $0x0f ++ BYTE $0x10; BYTE $0x11; BYTE $0x12; BYTE $0x13 ++ BYTE $0x3c; BYTE $0x3d; BYTE $0x32; BYTE $0x26 ++ BYTE $0x18; BYTE $0x19; BYTE $0x3f; BYTE $0x27 ++ BYTE $0x1c; BYTE $0x1d; BYTE $0x1e; BYTE $0x1f ++ BYTE $0x40; BYTE $0x5a; BYTE $0x7f; BYTE $0x7b ++ BYTE $0x5b; BYTE $0x6c; BYTE $0x50; BYTE $0x7d ++ BYTE $0x4d; BYTE $0x5d; BYTE $0x5c; BYTE $0x4e ++ BYTE $0x6b; BYTE $0x60; BYTE $0x4b; BYTE $0x61 ++ BYTE $0xf0; BYTE $0xf1; BYTE $0xf2; BYTE $0xf3 ++ BYTE $0xf4; BYTE $0xf5; BYTE $0xf6; BYTE $0xf7 ++ BYTE $0xf8; BYTE $0xf9; BYTE $0x7a; BYTE $0x5e ++ BYTE $0x4c; BYTE $0x7e; BYTE $0x6e; BYTE $0x6f ++ BYTE $0x7c; BYTE $0xc1; BYTE $0xc2; BYTE $0xc3 ++ BYTE $0xc4; BYTE $0xc5; BYTE $0xc6; BYTE $0xc7 ++ BYTE $0xc8; BYTE $0xc9; BYTE $0xd1; BYTE $0xd2 ++ BYTE $0xd3; BYTE $0xd4; BYTE $0xd5; BYTE $0xd6 ++ BYTE $0xd7; BYTE $0xd8; BYTE $0xd9; BYTE $0xe2 ++ BYTE $0xe3; BYTE $0xe4; BYTE $0xe5; BYTE $0xe6 ++ BYTE $0xe7; BYTE $0xe8; BYTE $0xe9; BYTE $0xad ++ BYTE $0xe0; BYTE $0xbd; BYTE $0x5f; BYTE $0x6d ++ BYTE $0x79; BYTE $0x81; BYTE $0x82; BYTE $0x83 ++ BYTE $0x84; BYTE $0x85; BYTE $0x86; BYTE $0x87 ++ BYTE $0x88; BYTE $0x89; BYTE $0x91; BYTE $0x92 ++ BYTE $0x93; BYTE $0x94; BYTE $0x95; BYTE $0x96 ++ BYTE $0x97; BYTE $0x98; BYTE $0x99; BYTE $0xa2 ++ BYTE $0xa3; BYTE $0xa4; BYTE $0xa5; BYTE $0xa6 ++ BYTE $0xa7; BYTE $0xa8; BYTE $0xa9; BYTE $0xc0 ++ BYTE $0x4f; BYTE $0xd0; BYTE $0xa1; BYTE $0x07 ++ BYTE $0x20; BYTE $0x21; BYTE $0x22; BYTE $0x23 ++ BYTE $0x24; BYTE $0x25; BYTE $0x06; BYTE $0x17 ++ BYTE $0x28; BYTE $0x29; BYTE $0x2a; BYTE $0x2b ++ BYTE $0x2c; BYTE $0x09; BYTE $0x0a; BYTE $0x1b ++ BYTE $0x30; BYTE $0x31; BYTE $0x1a; BYTE $0x33 ++ BYTE $0x34; BYTE $0x35; BYTE $0x36; BYTE $0x08 ++ BYTE $0x38; BYTE $0x39; BYTE $0x3a; BYTE $0x3b ++ BYTE $0x04; BYTE $0x14; BYTE $0x3e; BYTE $0xff ++ BYTE $0x41; BYTE $0xaa; BYTE $0x4a; BYTE $0xb1 ++ BYTE $0x9f; BYTE $0xb2; BYTE $0x6a; BYTE $0xb5 ++ BYTE $0xbb; BYTE $0xb4; BYTE $0x9a; BYTE $0x8a ++ BYTE $0xb0; BYTE $0xca; BYTE $0xaf; BYTE $0xbc ++ BYTE $0x90; BYTE $0x8f; BYTE $0xea; BYTE $0xfa ++ BYTE $0xbe; BYTE $0xa0; BYTE $0xb6; BYTE $0xb3 ++ BYTE $0x9d; BYTE $0xda; BYTE $0x9b; BYTE $0x8b ++ BYTE $0xb7; BYTE $0xb8; BYTE $0xb9; BYTE $0xab ++ BYTE $0x64; BYTE $0x65; BYTE $0x62; BYTE $0x66 ++ BYTE $0x63; BYTE $0x67; BYTE $0x9e; BYTE $0x68 ++ BYTE $0x74; BYTE $0x71; BYTE $0x72; BYTE $0x73 ++ BYTE $0x78; BYTE $0x75; BYTE $0x76; BYTE $0x77 ++ BYTE $0xac; BYTE $0x69; BYTE $0xed; BYTE $0xee ++ BYTE $0xeb; BYTE $0xef; BYTE $0xec; BYTE $0xbf ++ BYTE $0x80; BYTE $0xfd; BYTE $0xfe; BYTE $0xfb ++ BYTE $0xfc; BYTE $0xba; BYTE $0xae; BYTE $0x59 ++ BYTE $0x44; BYTE $0x45; BYTE $0x42; BYTE $0x46 ++ BYTE $0x43; BYTE $0x47; BYTE $0x9c; BYTE $0x48 ++ BYTE $0x54; BYTE $0x51; BYTE $0x52; BYTE $0x53 ++ BYTE $0x58; BYTE $0x55; BYTE $0x56; BYTE $0x57 ++ BYTE $0x8c; BYTE $0x49; BYTE $0xcd; BYTE $0xce ++ BYTE $0xcb; BYTE $0xcf; BYTE $0xcc; BYTE $0xe1 ++ BYTE $0x70; BYTE $0xdd; BYTE $0xde; BYTE $0xdb ++ BYTE $0xdc; BYTE $0x8d; BYTE $0x8e; BYTE $0xdf ++ ++retry: ++ WORD $0xB9931022 // TROO 2,2,b'0001' ++ BVS retry ++ RET ++ ++// func e2a(arr [] byte) ++// code page conversion from 1047 to 819 ++TEXT ·E2a(SB), NOSPLIT|NOFRAME, $0 ++ MOVD arg_base+0(FP), R2 // pointer to arry of characters ++ MOVD arg_len+8(FP), R3 // count ++ XOR R0, R0 ++ XOR R1, R1 ++ BYTE $0xA7; BYTE $0x15; BYTE $0x00; BYTE $0x82 // BRAS 1,(2+(256/2)) ++ ++ // EBCDIC -> ASCII conversion table: ++ BYTE $0x00; BYTE $0x01; BYTE $0x02; BYTE $0x03 ++ BYTE $0x9c; BYTE $0x09; BYTE $0x86; BYTE $0x7f ++ BYTE $0x97; BYTE $0x8d; BYTE $0x8e; BYTE $0x0b ++ BYTE $0x0c; BYTE $0x0d; BYTE $0x0e; BYTE $0x0f ++ BYTE $0x10; BYTE $0x11; BYTE $0x12; BYTE $0x13 ++ BYTE $0x9d; BYTE $0x0a; BYTE $0x08; BYTE $0x87 ++ BYTE $0x18; BYTE $0x19; BYTE $0x92; BYTE $0x8f ++ BYTE $0x1c; BYTE $0x1d; BYTE $0x1e; BYTE $0x1f ++ BYTE $0x80; BYTE $0x81; BYTE $0x82; BYTE $0x83 ++ BYTE $0x84; BYTE $0x85; BYTE $0x17; BYTE $0x1b ++ BYTE $0x88; BYTE $0x89; BYTE $0x8a; BYTE $0x8b ++ BYTE $0x8c; BYTE $0x05; BYTE $0x06; BYTE $0x07 ++ BYTE $0x90; BYTE $0x91; BYTE $0x16; BYTE $0x93 ++ BYTE $0x94; BYTE $0x95; BYTE $0x96; BYTE $0x04 ++ BYTE $0x98; BYTE $0x99; BYTE $0x9a; BYTE $0x9b ++ BYTE $0x14; BYTE $0x15; BYTE $0x9e; BYTE $0x1a ++ BYTE $0x20; BYTE $0xa0; BYTE $0xe2; BYTE $0xe4 ++ BYTE $0xe0; BYTE $0xe1; BYTE $0xe3; BYTE $0xe5 ++ BYTE $0xe7; BYTE $0xf1; BYTE $0xa2; BYTE $0x2e ++ BYTE $0x3c; BYTE $0x28; BYTE $0x2b; BYTE $0x7c ++ BYTE $0x26; BYTE $0xe9; BYTE $0xea; BYTE $0xeb ++ BYTE $0xe8; BYTE $0xed; BYTE $0xee; BYTE $0xef ++ BYTE $0xec; BYTE $0xdf; BYTE $0x21; BYTE $0x24 ++ BYTE $0x2a; BYTE $0x29; BYTE $0x3b; BYTE $0x5e ++ BYTE $0x2d; BYTE $0x2f; BYTE $0xc2; BYTE $0xc4 ++ BYTE $0xc0; BYTE $0xc1; BYTE $0xc3; BYTE $0xc5 ++ BYTE $0xc7; BYTE $0xd1; BYTE $0xa6; BYTE $0x2c ++ BYTE $0x25; BYTE $0x5f; BYTE $0x3e; BYTE $0x3f ++ BYTE $0xf8; BYTE $0xc9; BYTE $0xca; BYTE $0xcb ++ BYTE $0xc8; BYTE $0xcd; BYTE $0xce; BYTE $0xcf ++ BYTE $0xcc; BYTE $0x60; BYTE $0x3a; BYTE $0x23 ++ BYTE $0x40; BYTE $0x27; BYTE $0x3d; BYTE $0x22 ++ BYTE $0xd8; BYTE $0x61; BYTE $0x62; BYTE $0x63 ++ BYTE $0x64; BYTE $0x65; BYTE $0x66; BYTE $0x67 ++ BYTE $0x68; BYTE $0x69; BYTE $0xab; BYTE $0xbb ++ BYTE $0xf0; BYTE $0xfd; BYTE $0xfe; BYTE $0xb1 ++ BYTE $0xb0; BYTE $0x6a; BYTE $0x6b; BYTE $0x6c ++ BYTE $0x6d; BYTE $0x6e; BYTE $0x6f; BYTE $0x70 ++ BYTE $0x71; BYTE $0x72; BYTE $0xaa; BYTE $0xba ++ BYTE $0xe6; BYTE $0xb8; BYTE $0xc6; BYTE $0xa4 ++ BYTE $0xb5; BYTE $0x7e; BYTE $0x73; BYTE $0x74 ++ BYTE $0x75; BYTE $0x76; BYTE $0x77; BYTE $0x78 ++ BYTE $0x79; BYTE $0x7a; BYTE $0xa1; BYTE $0xbf ++ BYTE $0xd0; BYTE $0x5b; BYTE $0xde; BYTE $0xae ++ BYTE $0xac; BYTE $0xa3; BYTE $0xa5; BYTE $0xb7 ++ BYTE $0xa9; BYTE $0xa7; BYTE $0xb6; BYTE $0xbc ++ BYTE $0xbd; BYTE $0xbe; BYTE $0xdd; BYTE $0xa8 ++ BYTE $0xaf; BYTE $0x5d; BYTE $0xb4; BYTE $0xd7 ++ BYTE $0x7b; BYTE $0x41; BYTE $0x42; BYTE $0x43 ++ BYTE $0x44; BYTE $0x45; BYTE $0x46; BYTE $0x47 ++ BYTE $0x48; BYTE $0x49; BYTE $0xad; BYTE $0xf4 ++ BYTE $0xf6; BYTE $0xf2; BYTE $0xf3; BYTE $0xf5 ++ BYTE $0x7d; BYTE $0x4a; BYTE $0x4b; BYTE $0x4c ++ BYTE $0x4d; BYTE $0x4e; BYTE $0x4f; BYTE $0x50 ++ BYTE $0x51; BYTE $0x52; BYTE $0xb9; BYTE $0xfb ++ BYTE $0xfc; BYTE $0xf9; BYTE $0xfa; BYTE $0xff ++ BYTE $0x5c; BYTE $0xf7; BYTE $0x53; BYTE $0x54 ++ BYTE $0x55; BYTE $0x56; BYTE $0x57; BYTE $0x58 ++ BYTE $0x59; BYTE $0x5a; BYTE $0xb2; BYTE $0xd4 ++ BYTE $0xd6; BYTE $0xd2; BYTE $0xd3; BYTE $0xd5 ++ BYTE $0x30; BYTE $0x31; BYTE $0x32; BYTE $0x33 ++ BYTE $0x34; BYTE $0x35; BYTE $0x36; BYTE $0x37 ++ BYTE $0x38; BYTE $0x39; BYTE $0xb3; BYTE $0xdb ++ BYTE $0xdc; BYTE $0xd9; BYTE $0xda; BYTE $0x9f ++ ++retry: ++ WORD $0xB9931022 // TROO 2,2,b'0001' ++ BVS retry ++ RET +diff --git a/vendor/golang.org/x/sys/unix/epoll_zos.go b/vendor/golang.org/x/sys/unix/epoll_zos.go +deleted file mode 100644 +index 7753fddea817..000000000000 +--- a/vendor/golang.org/x/sys/unix/epoll_zos.go ++++ /dev/null +@@ -1,220 +0,0 @@ +-// Copyright 2020 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 zos && s390x +- +-package unix +- +-import ( +- "sync" +-) +- +-// This file simulates epoll on z/OS using poll. +- +-// Analogous to epoll_event on Linux. +-// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove? +-type EpollEvent struct { +- Events uint32 +- Fd int32 +- Pad int32 +-} +- +-const ( +- EPOLLERR = 0x8 +- EPOLLHUP = 0x10 +- EPOLLIN = 0x1 +- EPOLLMSG = 0x400 +- EPOLLOUT = 0x4 +- EPOLLPRI = 0x2 +- EPOLLRDBAND = 0x80 +- EPOLLRDNORM = 0x40 +- EPOLLWRBAND = 0x200 +- EPOLLWRNORM = 0x100 +- EPOLL_CTL_ADD = 0x1 +- EPOLL_CTL_DEL = 0x2 +- EPOLL_CTL_MOD = 0x3 +- // The following constants are part of the epoll API, but represent +- // currently unsupported functionality on z/OS. +- // EPOLL_CLOEXEC = 0x80000 +- // EPOLLET = 0x80000000 +- // EPOLLONESHOT = 0x40000000 +- // EPOLLRDHUP = 0x2000 // Typically used with edge-triggered notis +- // EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode +- // EPOLLWAKEUP = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability +-) +- +-// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL +-// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16). +- +-// epToPollEvt converts epoll event field to poll equivalent. +-// In epoll, Events is a 32-bit field, while poll uses 16 bits. +-func epToPollEvt(events uint32) int16 { +- var ep2p = map[uint32]int16{ +- EPOLLIN: POLLIN, +- EPOLLOUT: POLLOUT, +- EPOLLHUP: POLLHUP, +- EPOLLPRI: POLLPRI, +- EPOLLERR: POLLERR, +- } +- +- var pollEvts int16 = 0 +- for epEvt, pEvt := range ep2p { +- if (events & epEvt) != 0 { +- pollEvts |= pEvt +- } +- } +- +- return pollEvts +-} +- +-// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields. +-func pToEpollEvt(revents int16) uint32 { +- var p2ep = map[int16]uint32{ +- POLLIN: EPOLLIN, +- POLLOUT: EPOLLOUT, +- POLLHUP: EPOLLHUP, +- POLLPRI: EPOLLPRI, +- POLLERR: EPOLLERR, +- } +- +- var epollEvts uint32 = 0 +- for pEvt, epEvt := range p2ep { +- if (revents & pEvt) != 0 { +- epollEvts |= epEvt +- } +- } +- +- return epollEvts +-} +- +-// Per-process epoll implementation. +-type epollImpl struct { +- mu sync.Mutex +- epfd2ep map[int]*eventPoll +- nextEpfd int +-} +- +-// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances. +-// On Linux, this is an in-kernel data structure accessed through a fd. +-type eventPoll struct { +- mu sync.Mutex +- fds map[int]*EpollEvent +-} +- +-// epoll impl for this process. +-var impl epollImpl = epollImpl{ +- epfd2ep: make(map[int]*eventPoll), +- nextEpfd: 0, +-} +- +-func (e *epollImpl) epollcreate(size int) (epfd int, err error) { +- e.mu.Lock() +- defer e.mu.Unlock() +- epfd = e.nextEpfd +- e.nextEpfd++ +- +- e.epfd2ep[epfd] = &eventPoll{ +- fds: make(map[int]*EpollEvent), +- } +- return epfd, nil +-} +- +-func (e *epollImpl) epollcreate1(flag int) (fd int, err error) { +- return e.epollcreate(4) +-} +- +-func (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) { +- e.mu.Lock() +- defer e.mu.Unlock() +- +- ep, ok := e.epfd2ep[epfd] +- if !ok { +- +- return EBADF +- } +- +- switch op { +- case EPOLL_CTL_ADD: +- // TODO(neeilan): When we make epfds and fds disjoint, detect epoll +- // loops here (instances watching each other) and return ELOOP. +- if _, ok := ep.fds[fd]; ok { +- return EEXIST +- } +- ep.fds[fd] = event +- case EPOLL_CTL_MOD: +- if _, ok := ep.fds[fd]; !ok { +- return ENOENT +- } +- ep.fds[fd] = event +- case EPOLL_CTL_DEL: +- if _, ok := ep.fds[fd]; !ok { +- return ENOENT +- } +- delete(ep.fds, fd) +- +- } +- return nil +-} +- +-// Must be called while holding ep.mu +-func (ep *eventPoll) getFds() []int { +- fds := make([]int, len(ep.fds)) +- for fd := range ep.fds { +- fds = append(fds, fd) +- } +- return fds +-} +- +-func (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) { +- e.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait +- ep, ok := e.epfd2ep[epfd] +- +- if !ok { +- e.mu.Unlock() +- return 0, EBADF +- } +- +- pollfds := make([]PollFd, 4) +- for fd, epollevt := range ep.fds { +- pollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)}) +- } +- e.mu.Unlock() +- +- n, err = Poll(pollfds, msec) +- if err != nil { +- return n, err +- } +- +- i := 0 +- for _, pFd := range pollfds { +- if pFd.Revents != 0 { +- events[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)} +- i++ +- } +- +- if i == n { +- break +- } +- } +- +- return n, nil +-} +- +-func EpollCreate(size int) (fd int, err error) { +- return impl.epollcreate(size) +-} +- +-func EpollCreate1(flag int) (fd int, err error) { +- return impl.epollcreate1(flag) +-} +- +-func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { +- return impl.epollctl(epfd, op, fd, event) +-} +- +-// Because EpollWait mutates events, the caller is expected to coordinate +-// concurrent access if calling with the same epfd from multiple goroutines. +-func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { +- return impl.epollwait(epfd, events, msec) +-} +diff --git a/vendor/golang.org/x/sys/unix/fstatfs_zos.go b/vendor/golang.org/x/sys/unix/fstatfs_zos.go +deleted file mode 100644 +index c8bde601e772..000000000000 +--- a/vendor/golang.org/x/sys/unix/fstatfs_zos.go ++++ /dev/null +@@ -1,163 +0,0 @@ +-// Copyright 2020 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 zos && s390x +- +-package unix +- +-import ( +- "unsafe" +-) +- +-// This file simulates fstatfs on z/OS using fstatvfs and w_getmntent. +- +-func Fstatfs(fd int, stat *Statfs_t) (err error) { +- var stat_v Statvfs_t +- err = Fstatvfs(fd, &stat_v) +- if err == nil { +- // populate stat +- stat.Type = 0 +- stat.Bsize = stat_v.Bsize +- stat.Blocks = stat_v.Blocks +- stat.Bfree = stat_v.Bfree +- stat.Bavail = stat_v.Bavail +- stat.Files = stat_v.Files +- stat.Ffree = stat_v.Ffree +- stat.Fsid = stat_v.Fsid +- stat.Namelen = stat_v.Namemax +- stat.Frsize = stat_v.Frsize +- stat.Flags = stat_v.Flag +- for passn := 0; passn < 5; passn++ { +- switch passn { +- case 0: +- err = tryGetmntent64(stat) +- break +- case 1: +- err = tryGetmntent128(stat) +- break +- case 2: +- err = tryGetmntent256(stat) +- break +- case 3: +- err = tryGetmntent512(stat) +- break +- case 4: +- err = tryGetmntent1024(stat) +- break +- default: +- break +- } +- //proceed to return if: err is nil (found), err is nonnil but not ERANGE (another error occurred) +- if err == nil || err != nil && err != ERANGE { +- break +- } +- } +- } +- return err +-} +- +-func tryGetmntent64(stat *Statfs_t) (err error) { +- var mnt_ent_buffer struct { +- header W_Mnth +- filesys_info [64]W_Mntent +- } +- var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) +- fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) +- if err != nil { +- return err +- } +- err = ERANGE //return ERANGE if no match is found in this batch +- for i := 0; i < fs_count; i++ { +- if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { +- stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) +- err = nil +- break +- } +- } +- return err +-} +- +-func tryGetmntent128(stat *Statfs_t) (err error) { +- var mnt_ent_buffer struct { +- header W_Mnth +- filesys_info [128]W_Mntent +- } +- var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) +- fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) +- if err != nil { +- return err +- } +- err = ERANGE //return ERANGE if no match is found in this batch +- for i := 0; i < fs_count; i++ { +- if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { +- stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) +- err = nil +- break +- } +- } +- return err +-} +- +-func tryGetmntent256(stat *Statfs_t) (err error) { +- var mnt_ent_buffer struct { +- header W_Mnth +- filesys_info [256]W_Mntent +- } +- var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) +- fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) +- if err != nil { +- return err +- } +- err = ERANGE //return ERANGE if no match is found in this batch +- for i := 0; i < fs_count; i++ { +- if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { +- stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) +- err = nil +- break +- } +- } +- return err +-} +- +-func tryGetmntent512(stat *Statfs_t) (err error) { +- var mnt_ent_buffer struct { +- header W_Mnth +- filesys_info [512]W_Mntent +- } +- var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) +- fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) +- if err != nil { +- return err +- } +- err = ERANGE //return ERANGE if no match is found in this batch +- for i := 0; i < fs_count; i++ { +- if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { +- stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) +- err = nil +- break +- } +- } +- return err +-} +- +-func tryGetmntent1024(stat *Statfs_t) (err error) { +- var mnt_ent_buffer struct { +- header W_Mnth +- filesys_info [1024]W_Mntent +- } +- var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) +- fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) +- if err != nil { +- return err +- } +- err = ERANGE //return ERANGE if no match is found in this batch +- for i := 0; i < fs_count; i++ { +- if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { +- stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) +- err = nil +- break +- } +- } +- return err +-} +diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh +index fdcaa974d23b..4ed2e488b616 100644 +--- a/vendor/golang.org/x/sys/unix/mkerrors.sh ++++ b/vendor/golang.org/x/sys/unix/mkerrors.sh +@@ -263,6 +263,7 @@ struct ltchars { + #include + #include + #include ++#include + #include + #include + #include +@@ -549,6 +550,7 @@ ccflags="$@" + $2 !~ "NLA_TYPE_MASK" && + $2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ && + $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ || ++ $2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ || + $2 ~ /^FIORDCHK$/ || + $2 ~ /^SIOC/ || + $2 ~ /^TIOC/ || +diff --git a/vendor/golang.org/x/sys/unix/mmap_nomremap.go b/vendor/golang.org/x/sys/unix/mmap_nomremap.go +index 4b68e59780a2..7f602ffd26d4 100644 +--- a/vendor/golang.org/x/sys/unix/mmap_nomremap.go ++++ b/vendor/golang.org/x/sys/unix/mmap_nomremap.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build aix || darwin || dragonfly || freebsd || openbsd || solaris ++//go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos + + package unix + +diff --git a/vendor/golang.org/x/sys/unix/pagesize_unix.go b/vendor/golang.org/x/sys/unix/pagesize_unix.go +index 4d0a3430edc5..0482408d7c6c 100644 +--- a/vendor/golang.org/x/sys/unix/pagesize_unix.go ++++ b/vendor/golang.org/x/sys/unix/pagesize_unix.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris ++//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos + + // For Unix, get the pagesize from the runtime. + +diff --git a/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go b/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go +index 130398b6b767..b903c00604b9 100644 +--- a/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go ++++ b/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build darwin ++//go:build darwin || zos + + package unix + +diff --git a/vendor/golang.org/x/sys/unix/sockcmsg_zos.go b/vendor/golang.org/x/sys/unix/sockcmsg_zos.go +new file mode 100644 +index 000000000000..3e53dbc0286d +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/sockcmsg_zos.go +@@ -0,0 +1,58 @@ ++// 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. ++ ++// Socket control messages ++ ++package unix ++ ++import "unsafe" ++ ++// UnixCredentials encodes credentials into a socket control message ++// for sending to another process. This can be used for ++// authentication. ++func UnixCredentials(ucred *Ucred) []byte { ++ b := make([]byte, CmsgSpace(SizeofUcred)) ++ h := (*Cmsghdr)(unsafe.Pointer(&b[0])) ++ h.Level = SOL_SOCKET ++ h.Type = SCM_CREDENTIALS ++ h.SetLen(CmsgLen(SizeofUcred)) ++ *(*Ucred)(h.data(0)) = *ucred ++ return b ++} ++ ++// ParseUnixCredentials decodes a socket control message that contains ++// credentials in a Ucred structure. To receive such a message, the ++// SO_PASSCRED option must be enabled on the socket. ++func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) { ++ if m.Header.Level != SOL_SOCKET { ++ return nil, EINVAL ++ } ++ if m.Header.Type != SCM_CREDENTIALS { ++ return nil, EINVAL ++ } ++ ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0])) ++ return &ucred, nil ++} ++ ++// PktInfo4 encodes Inet4Pktinfo into a socket control message of type IP_PKTINFO. ++func PktInfo4(info *Inet4Pktinfo) []byte { ++ b := make([]byte, CmsgSpace(SizeofInet4Pktinfo)) ++ h := (*Cmsghdr)(unsafe.Pointer(&b[0])) ++ h.Level = SOL_IP ++ h.Type = IP_PKTINFO ++ h.SetLen(CmsgLen(SizeofInet4Pktinfo)) ++ *(*Inet4Pktinfo)(h.data(0)) = *info ++ return b ++} ++ ++// PktInfo6 encodes Inet6Pktinfo into a socket control message of type IPV6_PKTINFO. ++func PktInfo6(info *Inet6Pktinfo) []byte { ++ b := make([]byte, CmsgSpace(SizeofInet6Pktinfo)) ++ h := (*Cmsghdr)(unsafe.Pointer(&b[0])) ++ h.Level = SOL_IPV6 ++ h.Type = IPV6_PKTINFO ++ h.SetLen(CmsgLen(SizeofInet6Pktinfo)) ++ *(*Inet6Pktinfo)(h.data(0)) = *info ++ return b ++} +diff --git a/vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s b/vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s +new file mode 100644 +index 000000000000..3c4f33cb6a80 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s +@@ -0,0 +1,75 @@ ++// 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. ++ ++//go:build zos && s390x && gc ++ ++#include "textflag.h" ++ ++// provide the address of function variable to be fixed up. ++ ++TEXT ·getPipe2Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Pipe2(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_FlockAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Flock(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_GetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Getxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_NanosleepAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Nanosleep(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_SetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Setxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_Wait4Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Wait4(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_MountAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Mount(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_UnmountAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Unmount(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_UtimesNanoAtAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·UtimesNanoAt(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_UtimesNanoAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·UtimesNano(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_MkfifoatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Mkfifoat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_ChtagAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Chtag(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++TEXT ·get_ReadlinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Readlinkat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ +diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go b/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go +index 16dc6993799f..2f0fa76e4f65 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go ++++ b/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build darwin && go1.12 ++//go:build darwin + + package unix + +diff --git a/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/vendor/golang.org/x/sys/unix/syscall_freebsd.go +index 64d1bb4dba58..2b57e0f73bb8 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_freebsd.go ++++ b/vendor/golang.org/x/sys/unix/syscall_freebsd.go +@@ -13,6 +13,7 @@ + package unix + + import ( ++ "errors" + "sync" + "unsafe" + ) +@@ -169,25 +170,26 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { + func Uname(uname *Utsname) error { + mib := []_C_int{CTL_KERN, KERN_OSTYPE} + n := unsafe.Sizeof(uname.Sysname) +- if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil { ++ // Suppress ENOMEM errors to be compatible with the C library __xuname() implementation. ++ if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + return err + } + + mib = []_C_int{CTL_KERN, KERN_HOSTNAME} + n = unsafe.Sizeof(uname.Nodename) +- if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil { ++ if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + return err + } + + mib = []_C_int{CTL_KERN, KERN_OSRELEASE} + n = unsafe.Sizeof(uname.Release) +- if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil { ++ if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + return err + } + + mib = []_C_int{CTL_KERN, KERN_VERSION} + n = unsafe.Sizeof(uname.Version) +- if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil { ++ if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + return err + } + +@@ -205,7 +207,7 @@ func Uname(uname *Utsname) error { + + mib = []_C_int{CTL_HW, HW_MACHINE} + n = unsafe.Sizeof(uname.Machine) +- if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil { ++ if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + return err + } + +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go +index 0f85e29e621c..5682e2628ad0 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux.go +@@ -1849,6 +1849,105 @@ func Dup2(oldfd, newfd int) error { + //sys Fsmount(fd int, flags int, mountAttrs int) (fsfd int, err error) + //sys Fsopen(fsName string, flags int) (fd int, err error) + //sys Fspick(dirfd int, pathName string, flags int) (fd int, err error) ++ ++//sys fsconfig(fd int, cmd uint, key *byte, value *byte, aux int) (err error) ++ ++func fsconfigCommon(fd int, cmd uint, key string, value *byte, aux int) (err error) { ++ var keyp *byte ++ if keyp, err = BytePtrFromString(key); err != nil { ++ return ++ } ++ return fsconfig(fd, cmd, keyp, value, aux) ++} ++ ++// FsconfigSetFlag is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_SET_FLAG. ++// ++// fd is the filesystem context to act upon. ++// key the parameter key to set. ++func FsconfigSetFlag(fd int, key string) (err error) { ++ return fsconfigCommon(fd, FSCONFIG_SET_FLAG, key, nil, 0) ++} ++ ++// FsconfigSetString is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_SET_STRING. ++// ++// fd is the filesystem context to act upon. ++// key the parameter key to set. ++// value is the parameter value to set. ++func FsconfigSetString(fd int, key string, value string) (err error) { ++ var valuep *byte ++ if valuep, err = BytePtrFromString(value); err != nil { ++ return ++ } ++ return fsconfigCommon(fd, FSCONFIG_SET_STRING, key, valuep, 0) ++} ++ ++// FsconfigSetBinary is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_SET_BINARY. ++// ++// fd is the filesystem context to act upon. ++// key the parameter key to set. ++// value is the parameter value to set. ++func FsconfigSetBinary(fd int, key string, value []byte) (err error) { ++ if len(value) == 0 { ++ return EINVAL ++ } ++ return fsconfigCommon(fd, FSCONFIG_SET_BINARY, key, &value[0], len(value)) ++} ++ ++// FsconfigSetPath is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_SET_PATH. ++// ++// fd is the filesystem context to act upon. ++// key the parameter key to set. ++// path is a non-empty path for specified key. ++// atfd is a file descriptor at which to start lookup from or AT_FDCWD. ++func FsconfigSetPath(fd int, key string, path string, atfd int) (err error) { ++ var valuep *byte ++ if valuep, err = BytePtrFromString(path); err != nil { ++ return ++ } ++ return fsconfigCommon(fd, FSCONFIG_SET_PATH, key, valuep, atfd) ++} ++ ++// FsconfigSetPathEmpty is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_SET_PATH_EMPTY. The same as ++// FconfigSetPath but with AT_PATH_EMPTY implied. ++func FsconfigSetPathEmpty(fd int, key string, path string, atfd int) (err error) { ++ var valuep *byte ++ if valuep, err = BytePtrFromString(path); err != nil { ++ return ++ } ++ return fsconfigCommon(fd, FSCONFIG_SET_PATH_EMPTY, key, valuep, atfd) ++} ++ ++// FsconfigSetFd is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_SET_FD. ++// ++// fd is the filesystem context to act upon. ++// key the parameter key to set. ++// value is a file descriptor to be assigned to specified key. ++func FsconfigSetFd(fd int, key string, value int) (err error) { ++ return fsconfigCommon(fd, FSCONFIG_SET_FD, key, nil, value) ++} ++ ++// FsconfigCreate is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_CMD_CREATE. ++// ++// fd is the filesystem context to act upon. ++func FsconfigCreate(fd int) (err error) { ++ return fsconfig(fd, FSCONFIG_CMD_CREATE, nil, nil, 0) ++} ++ ++// FsconfigReconfigure is equivalent to fsconfig(2) called ++// with cmd == FSCONFIG_CMD_RECONFIGURE. ++// ++// fd is the filesystem context to act upon. ++func FsconfigReconfigure(fd int) (err error) { ++ return fsconfig(fd, FSCONFIG_CMD_RECONFIGURE, nil, nil, 0) ++} ++ + //sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64 + //sysnb Getpgid(pid int) (pgid int, err error) + +diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +index b473038c6155..312ae6ac1d21 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +@@ -4,11 +4,21 @@ + + //go:build zos && s390x + ++// Many of the following syscalls are not available on all versions of z/OS. ++// Some missing calls have legacy implementations/simulations but others ++// will be missing completely. To achieve consistent failing behaviour on ++// legacy systems, we first test the function pointer via a safeloading ++// mechanism to see if the function exists on a given system. Then execution ++// is branched to either continue the function call, or return an error. ++ + package unix + + import ( + "bytes" + "fmt" ++ "os" ++ "reflect" ++ "regexp" + "runtime" + "sort" + "strings" +@@ -17,17 +27,205 @@ import ( + "unsafe" + ) + ++//go:noescape ++func initZosLibVec() ++ ++//go:noescape ++func GetZosLibVec() uintptr ++ ++func init() { ++ initZosLibVec() ++ r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACE\x00"))[0]))) ++ if r0 != 0 { ++ n, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0) ++ ZosTraceLevel = int(n) ++ r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACEFD\x00"))[0]))) ++ if r0 != 0 { ++ fd, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0) ++ f := os.NewFile(fd, "zostracefile") ++ if f != nil { ++ ZosTracefile = f ++ } ++ } ++ ++ } ++} ++ ++//go:noescape ++func CallLeFuncWithErr(funcdesc uintptr, parms ...uintptr) (ret, errno2 uintptr, err Errno) ++ ++//go:noescape ++func CallLeFuncWithPtrReturn(funcdesc uintptr, parms ...uintptr) (ret, errno2 uintptr, err Errno) ++ ++// ------------------------------- ++// pointer validity test ++// good pointer returns 0 ++// bad pointer returns 1 ++// ++//go:nosplit ++func ptrtest(uintptr) uint64 ++ ++// Load memory at ptr location with error handling if the location is invalid ++// ++//go:noescape ++func safeload(ptr uintptr) (value uintptr, error uintptr) ++ + const ( +- O_CLOEXEC = 0 // Dummy value (not supported). +- AF_LOCAL = AF_UNIX // AF_LOCAL is an alias for AF_UNIX ++ entrypointLocationOffset = 8 // From function descriptor ++ ++ xplinkEyecatcher = 0x00c300c500c500f1 // ".C.E.E.1" ++ eyecatcherOffset = 16 // From function entrypoint (negative) ++ ppa1LocationOffset = 8 // From function entrypoint (negative) ++ ++ nameLenOffset = 0x14 // From PPA1 start ++ nameOffset = 0x16 // From PPA1 start + ) + +-func syscall_syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) +-func syscall_rawsyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) +-func syscall_syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) +-func syscall_rawsyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) +-func syscall_syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) +-func syscall_rawsyscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) ++func getPpaOffset(funcptr uintptr) int64 { ++ entrypoint, err := safeload(funcptr + entrypointLocationOffset) ++ if err != 0 { ++ return -1 ++ } ++ ++ // XPLink functions have ".C.E.E.1" as the first 8 bytes (EBCDIC) ++ val, err := safeload(entrypoint - eyecatcherOffset) ++ if err != 0 { ++ return -1 ++ } ++ if val != xplinkEyecatcher { ++ return -1 ++ } ++ ++ ppaoff, err := safeload(entrypoint - ppa1LocationOffset) ++ if err != 0 { ++ return -1 ++ } ++ ++ ppaoff >>= 32 ++ return int64(ppaoff) ++} ++ ++//------------------------------- ++// function descriptor pointer validity test ++// good pointer returns 0 ++// bad pointer returns 1 ++ ++// TODO: currently mksyscall_zos_s390x.go generate empty string for funcName ++// have correct funcName pass to the funcptrtest function ++func funcptrtest(funcptr uintptr, funcName string) uint64 { ++ entrypoint, err := safeload(funcptr + entrypointLocationOffset) ++ if err != 0 { ++ return 1 ++ } ++ ++ ppaoff := getPpaOffset(funcptr) ++ if ppaoff == -1 { ++ return 1 ++ } ++ ++ // PPA1 offset value is from the start of the entire function block, not the entrypoint ++ ppa1 := (entrypoint - eyecatcherOffset) + uintptr(ppaoff) ++ ++ nameLen, err := safeload(ppa1 + nameLenOffset) ++ if err != 0 { ++ return 1 ++ } ++ ++ nameLen >>= 48 ++ if nameLen > 128 { ++ return 1 ++ } ++ ++ // no function name input to argument end here ++ if funcName == "" { ++ return 0 ++ } ++ ++ var funcname [128]byte ++ for i := 0; i < int(nameLen); i += 8 { ++ v, err := safeload(ppa1 + nameOffset + uintptr(i)) ++ if err != 0 { ++ return 1 ++ } ++ funcname[i] = byte(v >> 56) ++ funcname[i+1] = byte(v >> 48) ++ funcname[i+2] = byte(v >> 40) ++ funcname[i+3] = byte(v >> 32) ++ funcname[i+4] = byte(v >> 24) ++ funcname[i+5] = byte(v >> 16) ++ funcname[i+6] = byte(v >> 8) ++ funcname[i+7] = byte(v) ++ } ++ ++ runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l ++ []uintptr{uintptr(unsafe.Pointer(&funcname[0])), nameLen}) ++ ++ name := string(funcname[:nameLen]) ++ if name != funcName { ++ return 1 ++ } ++ ++ return 0 ++} ++ ++// For detection of capabilities on a system. ++// Is function descriptor f a valid function? ++func isValidLeFunc(f uintptr) error { ++ ret := funcptrtest(f, "") ++ if ret != 0 { ++ return fmt.Errorf("Bad pointer, not an LE function ") ++ } ++ return nil ++} ++ ++// Retrieve function name from descriptor ++func getLeFuncName(f uintptr) (string, error) { ++ // assume it has been checked, only check ppa1 validity here ++ entry := ((*[2]uintptr)(unsafe.Pointer(f)))[1] ++ preamp := ((*[4]uint32)(unsafe.Pointer(entry - eyecatcherOffset))) ++ ++ offsetPpa1 := preamp[2] ++ if offsetPpa1 > 0x0ffff { ++ return "", fmt.Errorf("PPA1 offset seems too big 0x%x\n", offsetPpa1) ++ } ++ ++ ppa1 := uintptr(unsafe.Pointer(preamp)) + uintptr(offsetPpa1) ++ res := ptrtest(ppa1) ++ if res != 0 { ++ return "", fmt.Errorf("PPA1 address not valid") ++ } ++ ++ size := *(*uint16)(unsafe.Pointer(ppa1 + nameLenOffset)) ++ if size > 128 { ++ return "", fmt.Errorf("Function name seems too long, length=%d\n", size) ++ } ++ ++ var name [128]byte ++ funcname := (*[128]byte)(unsafe.Pointer(ppa1 + nameOffset)) ++ copy(name[0:size], funcname[0:size]) ++ ++ runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l ++ []uintptr{uintptr(unsafe.Pointer(&name[0])), uintptr(size)}) ++ ++ return string(name[:size]), nil ++} ++ ++// Check z/OS version ++func zosLeVersion() (version, release uint32) { ++ p1 := (*(*uintptr)(unsafe.Pointer(uintptr(1208)))) >> 32 ++ p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 88))) ++ p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 8))) ++ p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 984))) ++ vrm := *(*uint32)(unsafe.Pointer(p1 + 80)) ++ version = (vrm & 0x00ff0000) >> 16 ++ release = (vrm & 0x0000ff00) >> 8 ++ return ++} ++ ++// returns a zos C FILE * for stdio fd 0, 1, 2 ++func ZosStdioFilep(fd int32) uintptr { ++ return uintptr(*(*uint64)(unsafe.Pointer(uintptr(*(*uint64)(unsafe.Pointer(uintptr(*(*uint64)(unsafe.Pointer(uintptr(uint64(*(*uint32)(unsafe.Pointer(uintptr(1208)))) + 80))) + uint64((fd+2)<<3)))))))) ++} + + func copyStat(stat *Stat_t, statLE *Stat_LE_t) { + stat.Dev = uint64(statLE.Dev) +@@ -65,6 +263,21 @@ func (d *Dirent) NameString() string { + } + } + ++func DecodeData(dest []byte, sz int, val uint64) { ++ for i := 0; i < sz; i++ { ++ dest[sz-1-i] = byte((val >> (uint64(i * 8))) & 0xff) ++ } ++} ++ ++func EncodeData(data []byte) uint64 { ++ var value uint64 ++ sz := len(data) ++ for i := 0; i < sz; i++ { ++ value |= uint64(data[i]) << uint64(((sz - i - 1) * 8)) ++ } ++ return value ++} ++ + func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { + if sa.Port < 0 || sa.Port > 0xFFFF { + return nil, 0, EINVAL +@@ -74,7 +287,9 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { + p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) + p[0] = byte(sa.Port >> 8) + p[1] = byte(sa.Port) +- sa.raw.Addr = sa.Addr ++ for i := 0; i < len(sa.Addr); i++ { ++ sa.raw.Addr[i] = sa.Addr[i] ++ } + return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil + } + +@@ -88,7 +303,9 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { + p[0] = byte(sa.Port >> 8) + p[1] = byte(sa.Port) + sa.raw.Scope_id = sa.ZoneId +- sa.raw.Addr = sa.Addr ++ for i := 0; i < len(sa.Addr); i++ { ++ sa.raw.Addr[i] = sa.Addr[i] ++ } + return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil + } + +@@ -146,7 +363,9 @@ func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) { + sa := new(SockaddrInet4) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) +- sa.Addr = pp.Addr ++ for i := 0; i < len(sa.Addr); i++ { ++ sa.Addr[i] = pp.Addr[i] ++ } + return sa, nil + + case AF_INET6: +@@ -155,7 +374,9 @@ func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) { + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + sa.ZoneId = pp.Scope_id +- sa.Addr = pp.Addr ++ for i := 0; i < len(sa.Addr); i++ { ++ sa.Addr[i] = pp.Addr[i] ++ } + return sa, nil + } + return nil, EAFNOSUPPORT +@@ -177,6 +398,43 @@ func Accept(fd int) (nfd int, sa Sockaddr, err error) { + return + } + ++func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) { ++ var rsa RawSockaddrAny ++ var len _Socklen = SizeofSockaddrAny ++ nfd, err = accept4(fd, &rsa, &len, flags) ++ if err != nil { ++ return ++ } ++ if len > SizeofSockaddrAny { ++ panic("RawSockaddrAny too small") ++ } ++ // TODO(neeilan): Remove 0 in call ++ sa, err = anyToSockaddr(0, &rsa) ++ if err != nil { ++ Close(nfd) ++ nfd = 0 ++ } ++ return ++} ++ ++func Ctermid() (tty string, err error) { ++ var termdev [1025]byte ++ runtime.EnterSyscall() ++ r0, err2, err1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___CTERMID_A<<4, uintptr(unsafe.Pointer(&termdev[0]))) ++ runtime.ExitSyscall() ++ if r0 == 0 { ++ return "", fmt.Errorf("%s (errno2=0x%x)\n", err1.Error(), err2) ++ } ++ s := string(termdev[:]) ++ idx := strings.Index(s, string(rune(0))) ++ if idx == -1 { ++ tty = s ++ } else { ++ tty = s[:idx] ++ } ++ return ++} ++ + func (iov *Iovec) SetLen(length int) { + iov.Len = uint64(length) + } +@@ -190,10 +448,16 @@ func (cmsg *Cmsghdr) SetLen(length int) { + } + + //sys fcntl(fd int, cmd int, arg int) (val int, err error) ++//sys Flistxattr(fd int, dest []byte) (sz int, err error) = SYS___FLISTXATTR_A ++//sys Fremovexattr(fd int, attr string) (err error) = SYS___FREMOVEXATTR_A + //sys read(fd int, p []byte) (n int, err error) + //sys write(fd int, p []byte) (n int, err error) + ++//sys Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) = SYS___FGETXATTR_A ++//sys Fsetxattr(fd int, attr string, data []byte, flag int) (err error) = SYS___FSETXATTR_A ++ + //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = SYS___ACCEPT_A ++//sys accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) = SYS___ACCEPT4_A + //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___BIND_A + //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___CONNECT_A + //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) +@@ -204,6 +468,7 @@ func (cmsg *Cmsghdr) SetLen(length int) { + //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) + //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETPEERNAME_A + //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETSOCKNAME_A ++//sys Removexattr(path string, attr string) (err error) = SYS___REMOVEXATTR_A + //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = SYS___RECVFROM_A + //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = SYS___SENDTO_A + //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = SYS___RECVMSG_A +@@ -212,6 +477,10 @@ func (cmsg *Cmsghdr) SetLen(length int) { + //sys munmap(addr uintptr, length uintptr) (err error) = SYS_MUNMAP + //sys ioctl(fd int, req int, arg uintptr) (err error) = SYS_IOCTL + //sys ioctlPtr(fd int, req int, arg unsafe.Pointer) (err error) = SYS_IOCTL ++//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) = SYS_SHMAT ++//sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) = SYS_SHMCTL64 ++//sys shmdt(addr uintptr) (err error) = SYS_SHMDT ++//sys shmget(key int, size int, flag int) (id int, err error) = SYS_SHMGET + + //sys Access(path string, mode uint32) (err error) = SYS___ACCESS_A + //sys Chdir(path string) (err error) = SYS___CHDIR_A +@@ -220,14 +489,31 @@ func (cmsg *Cmsghdr) SetLen(length int) { + //sys Creat(path string, mode uint32) (fd int, err error) = SYS___CREAT_A + //sys Dup(oldfd int) (fd int, err error) + //sys Dup2(oldfd int, newfd int) (err error) ++//sys Dup3(oldfd int, newfd int, flags int) (err error) = SYS_DUP3 ++//sys Dirfd(dirp uintptr) (fd int, err error) = SYS_DIRFD ++//sys EpollCreate(size int) (fd int, err error) = SYS_EPOLL_CREATE ++//sys EpollCreate1(flags int) (fd int, err error) = SYS_EPOLL_CREATE1 ++//sys EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) = SYS_EPOLL_CTL ++//sys EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) = SYS_EPOLL_PWAIT ++//sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) = SYS_EPOLL_WAIT + //sys Errno2() (er2 int) = SYS___ERRNO2 +-//sys Err2ad() (eadd *int) = SYS___ERR2AD ++//sys Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD + //sys Exit(code int) ++//sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error) = SYS___FACCESSAT_A ++ ++func Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) { ++ return Faccessat(dirfd, path, mode, flags) ++} ++ + //sys Fchdir(fd int) (err error) + //sys Fchmod(fd int, mode uint32) (err error) ++//sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) = SYS___FCHMODAT_A + //sys Fchown(fd int, uid int, gid int) (err error) ++//sys Fchownat(fd int, path string, uid int, gid int, flags int) (err error) = SYS___FCHOWNAT_A + //sys FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) = SYS_FCNTL ++//sys Fdatasync(fd int) (err error) = SYS_FDATASYNC + //sys fstat(fd int, stat *Stat_LE_t) (err error) ++//sys fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) = SYS___FSTATAT_A + + func Fstat(fd int, stat *Stat_t) (err error) { + var statLE Stat_LE_t +@@ -236,28 +522,208 @@ func Fstat(fd int, stat *Stat_t) (err error) { + return + } + ++func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) { ++ var statLE Stat_LE_t ++ err = fstatat(dirfd, path, &statLE, flags) ++ copyStat(stat, &statLE) ++ return ++} ++ ++func impl_Getxattr(path string, attr string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(dest) > 0 { ++ _p2 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest))) ++ sz = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_GetxattrAddr() *(func(path string, attr string, dest []byte) (sz int, err error)) ++ ++var Getxattr = enter_Getxattr ++ ++func enter_Getxattr(path string, attr string, dest []byte) (sz int, err error) { ++ funcref := get_GetxattrAddr() ++ if validGetxattr() { ++ *funcref = impl_Getxattr ++ } else { ++ *funcref = error_Getxattr ++ } ++ return (*funcref)(path, attr, dest) ++} ++ ++func error_Getxattr(path string, attr string, dest []byte) (sz int, err error) { ++ return -1, ENOSYS ++} ++ ++func validGetxattr() bool { ++ if funcptrtest(GetZosLibVec()+SYS___GETXATTR_A<<4, "") == 0 { ++ if name, err := getLeFuncName(GetZosLibVec() + SYS___GETXATTR_A<<4); err == nil { ++ return name == "__getxattr_a" ++ } ++ } ++ return false ++} ++ ++//sys Lgetxattr(link string, attr string, dest []byte) (sz int, err error) = SYS___LGETXATTR_A ++//sys Lsetxattr(path string, attr string, data []byte, flags int) (err error) = SYS___LSETXATTR_A ++ ++func impl_Setxattr(path string, attr string, data []byte, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(data) > 0 { ++ _p2 = unsafe.Pointer(&data[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_SetxattrAddr() *(func(path string, attr string, data []byte, flags int) (err error)) ++ ++var Setxattr = enter_Setxattr ++ ++func enter_Setxattr(path string, attr string, data []byte, flags int) (err error) { ++ funcref := get_SetxattrAddr() ++ if validSetxattr() { ++ *funcref = impl_Setxattr ++ } else { ++ *funcref = error_Setxattr ++ } ++ return (*funcref)(path, attr, data, flags) ++} ++ ++func error_Setxattr(path string, attr string, data []byte, flags int) (err error) { ++ return ENOSYS ++} ++ ++func validSetxattr() bool { ++ if funcptrtest(GetZosLibVec()+SYS___SETXATTR_A<<4, "") == 0 { ++ if name, err := getLeFuncName(GetZosLibVec() + SYS___SETXATTR_A<<4); err == nil { ++ return name == "__setxattr_a" ++ } ++ } ++ return false ++} ++ ++//sys Fstatfs(fd int, buf *Statfs_t) (err error) = SYS_FSTATFS + //sys Fstatvfs(fd int, stat *Statvfs_t) (err error) = SYS_FSTATVFS + //sys Fsync(fd int) (err error) ++//sys Futimes(fd int, tv []Timeval) (err error) = SYS_FUTIMES ++//sys Futimesat(dirfd int, path string, tv []Timeval) (err error) = SYS___FUTIMESAT_A + //sys Ftruncate(fd int, length int64) (err error) +-//sys Getpagesize() (pgsize int) = SYS_GETPAGESIZE ++//sys Getrandom(buf []byte, flags int) (n int, err error) = SYS_GETRANDOM ++//sys InotifyInit() (fd int, err error) = SYS_INOTIFY_INIT ++//sys InotifyInit1(flags int) (fd int, err error) = SYS_INOTIFY_INIT1 ++//sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) = SYS___INOTIFY_ADD_WATCH_A ++//sys InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) = SYS_INOTIFY_RM_WATCH ++//sys Listxattr(path string, dest []byte) (sz int, err error) = SYS___LISTXATTR_A ++//sys Llistxattr(path string, dest []byte) (sz int, err error) = SYS___LLISTXATTR_A ++//sys Lremovexattr(path string, attr string) (err error) = SYS___LREMOVEXATTR_A ++//sys Lutimes(path string, tv []Timeval) (err error) = SYS___LUTIMES_A + //sys Mprotect(b []byte, prot int) (err error) = SYS_MPROTECT + //sys Msync(b []byte, flags int) (err error) = SYS_MSYNC ++//sys Console2(cmsg *ConsMsg2, modstr *byte, concmd *uint32) (err error) = SYS___CONSOLE2 ++ ++// Pipe2 begin ++ ++//go:nosplit ++func getPipe2Addr() *(func([]int, int) error) ++ ++var Pipe2 = pipe2Enter ++ ++func pipe2Enter(p []int, flags int) (err error) { ++ if funcptrtest(GetZosLibVec()+SYS_PIPE2<<4, "") == 0 { ++ *getPipe2Addr() = pipe2Impl ++ } else { ++ *getPipe2Addr() = pipe2Error ++ } ++ return (*getPipe2Addr())(p, flags) ++} ++ ++func pipe2Impl(p []int, flags int) (err error) { ++ var pp [2]_C_int ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PIPE2<<4, uintptr(unsafe.Pointer(&pp[0])), uintptr(flags)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } else { ++ p[0] = int(pp[0]) ++ p[1] = int(pp[1]) ++ } ++ return ++} ++func pipe2Error(p []int, flags int) (err error) { ++ return fmt.Errorf("Pipe2 is not available on this system") ++} ++ ++// Pipe2 end ++ + //sys Poll(fds []PollFd, timeout int) (n int, err error) = SYS_POLL ++ ++func Readdir(dir uintptr) (dirent *Dirent, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READDIR_A<<4, uintptr(dir)) ++ runtime.ExitSyscall() ++ dirent = (*Dirent)(unsafe.Pointer(r0)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//sys Readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) = SYS___READDIR_R_A ++//sys Statfs(path string, buf *Statfs_t) (err error) = SYS___STATFS_A ++//sys Syncfs(fd int) (err error) = SYS_SYNCFS + //sys Times(tms *Tms) (ticks uintptr, err error) = SYS_TIMES + //sys W_Getmntent(buff *byte, size int) (lastsys int, err error) = SYS_W_GETMNTENT + //sys W_Getmntent_A(buff *byte, size int) (lastsys int, err error) = SYS___W_GETMNTENT_A + + //sys mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) = SYS___MOUNT_A +-//sys unmount(filesystem string, mtm int) (err error) = SYS___UMOUNT_A ++//sys unmount_LE(filesystem string, mtm int) (err error) = SYS___UMOUNT_A + //sys Chroot(path string) (err error) = SYS___CHROOT_A + //sys Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) = SYS_SELECT +-//sysnb Uname(buf *Utsname) (err error) = SYS___UNAME_A ++//sysnb Uname(buf *Utsname) (err error) = SYS_____OSNAME_A ++//sys Unshare(flags int) (err error) = SYS_UNSHARE + + func Ptsname(fd int) (name string, err error) { +- r0, _, e1 := syscall_syscall(SYS___PTSNAME_A, uintptr(fd), 0, 0) +- name = u2s(unsafe.Pointer(r0)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___PTSNAME_A<<4, uintptr(fd)) ++ runtime.ExitSyscall() ++ if r0 == 0 { ++ err = errnoErr2(e1, e2) ++ } else { ++ name = u2s(unsafe.Pointer(r0)) + } + return + } +@@ -272,13 +738,19 @@ func u2s(cstr unsafe.Pointer) string { + } + + func Close(fd int) (err error) { +- _, _, e1 := syscall_syscall(SYS_CLOSE, uintptr(fd), 0, 0) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSE<<4, uintptr(fd)) ++ runtime.ExitSyscall() + for i := 0; e1 == EAGAIN && i < 10; i++ { +- _, _, _ = syscall_syscall(SYS_USLEEP, uintptr(10), 0, 0) +- _, _, e1 = syscall_syscall(SYS_CLOSE, uintptr(fd), 0, 0) ++ runtime.EnterSyscall() ++ CallLeFuncWithErr(GetZosLibVec()+SYS_USLEEP<<4, uintptr(10)) ++ runtime.ExitSyscall() ++ runtime.EnterSyscall() ++ r0, e2, e1 = CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSE<<4, uintptr(fd)) ++ runtime.ExitSyscall() + } +- if e1 != 0 { +- err = errnoErr(e1) ++ if r0 != 0 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -288,9 +760,15 @@ func Madvise(b []byte, advice int) (err error) { + return + } + ++func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { ++ return mapper.Mmap(fd, offset, length, prot, flags) ++} ++ ++func Munmap(b []byte) (err error) { ++ return mapper.Munmap(b) ++} ++ + //sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A +-//sysnb Getegid() (egid int) +-//sysnb Geteuid() (uid int) + //sysnb Getgid() (gid int) + //sysnb Getpid() (pid int) + //sysnb Getpgid(pid int) (pgid int, err error) = SYS_GETPGID +@@ -317,11 +795,14 @@ func Getrusage(who int, rusage *Rusage) (err error) { + return + } + ++//sys Getegid() (egid int) = SYS_GETEGID ++//sys Geteuid() (euid int) = SYS_GETEUID + //sysnb Getsid(pid int) (sid int, err error) = SYS_GETSID + //sysnb Getuid() (uid int) + //sysnb Kill(pid int, sig Signal) (err error) + //sys Lchown(path string, uid int, gid int) (err error) = SYS___LCHOWN_A + //sys Link(path string, link string) (err error) = SYS___LINK_A ++//sys Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) = SYS___LINKAT_A + //sys Listen(s int, n int) (err error) + //sys lstat(path string, stat *Stat_LE_t) (err error) = SYS___LSTAT_A + +@@ -332,15 +813,150 @@ func Lstat(path string, stat *Stat_t) (err error) { + return + } + ++// for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/ ++func isSpecialPath(path []byte) (v bool) { ++ var special = [4][8]byte{ ++ [8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, ++ [8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, ++ [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, ++ [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} ++ ++ var i, j int ++ for i = 0; i < len(special); i++ { ++ for j = 0; j < len(special[i]); j++ { ++ if path[j] != special[i][j] { ++ break ++ } ++ } ++ if j == len(special[i]) { ++ return true ++ } ++ } ++ return false ++} ++ ++func realpath(srcpath string, abspath []byte) (pathlen int, errno int) { ++ var source [1024]byte ++ copy(source[:], srcpath) ++ source[len(srcpath)] = 0 ++ ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___REALPATH_A<<4, //__realpath_a() ++ []uintptr{uintptr(unsafe.Pointer(&source[0])), ++ uintptr(unsafe.Pointer(&abspath[0]))}) ++ if ret != 0 { ++ index := bytes.IndexByte(abspath[:], byte(0)) ++ if index != -1 { ++ return index, 0 ++ } ++ } else { ++ errptr := (*int)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, []uintptr{}))) //__errno() ++ return 0, *errptr ++ } ++ return 0, 245 // EBADDATA 245 ++} ++ ++func Readlink(path string, buf []byte) (n int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(buf) > 0 { ++ _p1 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ n = int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___READLINK_A<<4, ++ []uintptr{uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))})) ++ runtime.KeepAlive(unsafe.Pointer(_p0)) ++ if n == -1 { ++ value := *(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, []uintptr{}))) ++ err = errnoErr(Errno(value)) ++ } else { ++ if buf[0] == '$' { ++ if isSpecialPath(buf[1:9]) { ++ cnt, err1 := realpath(path, buf) ++ if err1 == 0 { ++ n = cnt ++ } ++ } ++ } ++ } ++ return ++} ++ ++func impl_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(buf) > 0 { ++ _p1 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READLINKAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))) ++ runtime.ExitSyscall() ++ n = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ return n, err ++ } else { ++ if buf[0] == '$' { ++ if isSpecialPath(buf[1:9]) { ++ cnt, err1 := realpath(path, buf) ++ if err1 == 0 { ++ n = cnt ++ } ++ } ++ } ++ } ++ return ++} ++ ++//go:nosplit ++func get_ReadlinkatAddr() *(func(dirfd int, path string, buf []byte) (n int, err error)) ++ ++var Readlinkat = enter_Readlinkat ++ ++func enter_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { ++ funcref := get_ReadlinkatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___READLINKAT_A<<4, "") == 0 { ++ *funcref = impl_Readlinkat ++ } else { ++ *funcref = error_Readlinkat ++ } ++ return (*funcref)(dirfd, path, buf) ++} ++ ++func error_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { ++ n = -1 ++ err = ENOSYS ++ return ++} ++ + //sys Mkdir(path string, mode uint32) (err error) = SYS___MKDIR_A ++//sys Mkdirat(dirfd int, path string, mode uint32) (err error) = SYS___MKDIRAT_A + //sys Mkfifo(path string, mode uint32) (err error) = SYS___MKFIFO_A + //sys Mknod(path string, mode uint32, dev int) (err error) = SYS___MKNOD_A ++//sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) = SYS___MKNODAT_A ++//sys PivotRoot(newroot string, oldroot string) (err error) = SYS___PIVOT_ROOT_A + //sys Pread(fd int, p []byte, offset int64) (n int, err error) + //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) +-//sys Readlink(path string, buf []byte) (n int, err error) = SYS___READLINK_A ++//sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) = SYS___PRCTL_A ++//sysnb Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT + //sys Rename(from string, to string) (err error) = SYS___RENAME_A ++//sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) = SYS___RENAMEAT_A ++//sys Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) = SYS___RENAMEAT2_A + //sys Rmdir(path string) (err error) = SYS___RMDIR_A + //sys Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK ++//sys Setegid(egid int) (err error) = SYS_SETEGID ++//sys Seteuid(euid int) (err error) = SYS_SETEUID ++//sys Sethostname(p []byte) (err error) = SYS___SETHOSTNAME_A ++//sys Setns(fd int, nstype int) (err error) = SYS_SETNS + //sys Setpriority(which int, who int, prio int) (err error) + //sysnb Setpgid(pid int, pgid int) (err error) = SYS_SETPGID + //sysnb Setrlimit(resource int, lim *Rlimit) (err error) +@@ -360,32 +976,57 @@ func Stat(path string, sta *Stat_t) (err error) { + } + + //sys Symlink(path string, link string) (err error) = SYS___SYMLINK_A ++//sys Symlinkat(oldPath string, dirfd int, newPath string) (err error) = SYS___SYMLINKAT_A + //sys Sync() = SYS_SYNC + //sys Truncate(path string, length int64) (err error) = SYS___TRUNCATE_A + //sys Tcgetattr(fildes int, termptr *Termios) (err error) = SYS_TCGETATTR + //sys Tcsetattr(fildes int, when int, termptr *Termios) (err error) = SYS_TCSETATTR + //sys Umask(mask int) (oldmask int) + //sys Unlink(path string) (err error) = SYS___UNLINK_A ++//sys Unlinkat(dirfd int, path string, flags int) (err error) = SYS___UNLINKAT_A + //sys Utime(path string, utim *Utimbuf) (err error) = SYS___UTIME_A + + //sys open(path string, mode int, perm uint32) (fd int, err error) = SYS___OPEN_A + + func Open(path string, mode int, perm uint32) (fd int, err error) { ++ if mode&O_ACCMODE == 0 { ++ mode |= O_RDONLY ++ } + return open(path, mode, perm) + } + +-func Mkfifoat(dirfd int, path string, mode uint32) (err error) { +- wd, err := Getwd() +- if err != nil { +- return err ++//sys openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) = SYS___OPENAT_A ++ ++func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { ++ if flags&O_ACCMODE == 0 { ++ flags |= O_RDONLY + } ++ return openat(dirfd, path, flags, mode) ++} + +- if err := Fchdir(dirfd); err != nil { +- return err ++//sys openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) = SYS___OPENAT2_A ++ ++func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) { ++ if how.Flags&O_ACCMODE == 0 { ++ how.Flags |= O_RDONLY + } +- defer Chdir(wd) ++ return openat2(dirfd, path, how, SizeofOpenHow) ++} + +- return Mkfifo(path, mode) ++func ZosFdToPath(dirfd int) (path string, err error) { ++ var buffer [1024]byte ++ runtime.EnterSyscall() ++ ret, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_W_IOCTL<<4, uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))) ++ runtime.ExitSyscall() ++ if ret == 0 { ++ zb := bytes.IndexByte(buffer[:], 0) ++ if zb == -1 { ++ zb = len(buffer) ++ } ++ CallLeFuncWithErr(GetZosLibVec()+SYS___E2A_L<<4, uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)) ++ return string(buffer[:zb]), nil ++ } ++ return "", errnoErr2(e1, e2) + } + + //sys remove(path string) (err error) +@@ -403,10 +1044,12 @@ func Getcwd(buf []byte) (n int, err error) { + } else { + p = unsafe.Pointer(&_zero) + } +- _, _, e := syscall_syscall(SYS___GETCWD_A, uintptr(p), uintptr(len(buf)), 0) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___GETCWD_A<<4, uintptr(p), uintptr(len(buf))) ++ runtime.ExitSyscall() + n = clen(buf) + 1 +- if e != 0 { +- err = errnoErr(e) ++ if r0 == 0 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -520,9 +1163,41 @@ func (w WaitStatus) StopSignal() Signal { + + func (w WaitStatus) TrapCause() int { return -1 } + ++//sys waitid(idType int, id int, info *Siginfo, options int) (err error) ++ ++func Waitid(idType int, id int, info *Siginfo, options int, rusage *Rusage) (err error) { ++ return waitid(idType, id, info, options) ++} ++ + //sys waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) + +-func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { ++func impl_Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAIT4<<4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage))) ++ runtime.ExitSyscall() ++ wpid = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_Wait4Addr() *(func(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error)) ++ ++var Wait4 = enter_Wait4 ++ ++func enter_Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { ++ funcref := get_Wait4Addr() ++ if funcptrtest(GetZosLibVec()+SYS_WAIT4<<4, "") == 0 { ++ *funcref = impl_Wait4 ++ } else { ++ *funcref = legacyWait4 ++ } ++ return (*funcref)(pid, wstatus, options, rusage) ++} ++ ++func legacyWait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { + // TODO(mundaym): z/OS doesn't have wait4. I don't think getrusage does what we want. + // At the moment rusage will not be touched. + var status _C_int +@@ -571,23 +1246,62 @@ func Pipe(p []int) (err error) { + } + var pp [2]_C_int + err = pipe(&pp) +- if err == nil { +- p[0] = int(pp[0]) +- p[1] = int(pp[1]) +- } ++ p[0] = int(pp[0]) ++ p[1] = int(pp[1]) + return + } + + //sys utimes(path string, timeval *[2]Timeval) (err error) = SYS___UTIMES_A + + func Utimes(path string, tv []Timeval) (err error) { ++ if tv == nil { ++ return utimes(path, nil) ++ } + if len(tv) != 2 { + return EINVAL + } + return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) + } + +-func UtimesNano(path string, ts []Timespec) error { ++//sys utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) = SYS___UTIMENSAT_A ++ ++func validUtimensat() bool { ++ if funcptrtest(GetZosLibVec()+SYS___UTIMENSAT_A<<4, "") == 0 { ++ if name, err := getLeFuncName(GetZosLibVec() + SYS___UTIMENSAT_A<<4); err == nil { ++ return name == "__utimensat_a" ++ } ++ } ++ return false ++} ++ ++// Begin UtimesNano ++ ++//go:nosplit ++func get_UtimesNanoAddr() *(func(path string, ts []Timespec) (err error)) ++ ++var UtimesNano = enter_UtimesNano ++ ++func enter_UtimesNano(path string, ts []Timespec) (err error) { ++ funcref := get_UtimesNanoAddr() ++ if validUtimensat() { ++ *funcref = utimesNanoImpl ++ } else { ++ *funcref = legacyUtimesNano ++ } ++ return (*funcref)(path, ts) ++} ++ ++func utimesNanoImpl(path string, ts []Timespec) (err error) { ++ if ts == nil { ++ return utimensat(AT_FDCWD, path, nil, 0) ++ } ++ if len(ts) != 2 { ++ return EINVAL ++ } ++ return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) ++} ++ ++func legacyUtimesNano(path string, ts []Timespec) (err error) { + if len(ts) != 2 { + return EINVAL + } +@@ -600,6 +1314,70 @@ func UtimesNano(path string, ts []Timespec) error { + return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) + } + ++// End UtimesNano ++ ++// Begin UtimesNanoAt ++ ++//go:nosplit ++func get_UtimesNanoAtAddr() *(func(dirfd int, path string, ts []Timespec, flags int) (err error)) ++ ++var UtimesNanoAt = enter_UtimesNanoAt ++ ++func enter_UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) (err error) { ++ funcref := get_UtimesNanoAtAddr() ++ if validUtimensat() { ++ *funcref = utimesNanoAtImpl ++ } else { ++ *funcref = legacyUtimesNanoAt ++ } ++ return (*funcref)(dirfd, path, ts, flags) ++} ++ ++func utimesNanoAtImpl(dirfd int, path string, ts []Timespec, flags int) (err error) { ++ if ts == nil { ++ return utimensat(dirfd, path, nil, flags) ++ } ++ if len(ts) != 2 { ++ return EINVAL ++ } ++ return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) ++} ++ ++func legacyUtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) (err error) { ++ if path[0] != '/' { ++ dirPath, err := ZosFdToPath(dirfd) ++ if err != nil { ++ return err ++ } ++ path = dirPath + "/" + path ++ } ++ if flags == AT_SYMLINK_NOFOLLOW { ++ if len(ts) != 2 { ++ return EINVAL ++ } ++ ++ if ts[0].Nsec >= 5e8 { ++ ts[0].Sec++ ++ } ++ ts[0].Nsec = 0 ++ if ts[1].Nsec >= 5e8 { ++ ts[1].Sec++ ++ } ++ ts[1].Nsec = 0 ++ ++ // Not as efficient as it could be because Timespec and ++ // Timeval have different types in the different OSes ++ tv := []Timeval{ ++ NsecToTimeval(TimespecToNsec(ts[0])), ++ NsecToTimeval(TimespecToNsec(ts[1])), ++ } ++ return Lutimes(path, tv) ++ } ++ return UtimesNano(path, ts) ++} ++ ++// End UtimesNanoAt ++ + func Getsockname(fd int) (sa Sockaddr, err error) { + var rsa RawSockaddrAny + var len _Socklen = SizeofSockaddrAny +@@ -1186,67 +1964,46 @@ func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) + return n, nil + } + +-func Opendir(name string) (uintptr, error) { +- p, err := BytePtrFromString(name) +- if err != nil { +- return 0, err +- } +- dir, _, e := syscall_syscall(SYS___OPENDIR_A, uintptr(unsafe.Pointer(p)), 0, 0) +- runtime.KeepAlive(unsafe.Pointer(p)) +- if e != 0 { +- err = errnoErr(e) +- } +- return dir, err +-} +- +-// clearsyscall.Errno resets the errno value to 0. +-func clearErrno() +- +-func Readdir(dir uintptr) (*Dirent, error) { +- var ent Dirent +- var res uintptr +- // __readdir_r_a returns errno at the end of the directory stream, rather than 0. +- // Therefore to avoid false positives we clear errno before calling it. +- +- // TODO(neeilan): Commented this out to get sys/unix compiling on z/OS. Uncomment and fix. Error: "undefined: clearsyscall" +- //clearsyscall.Errno() // TODO(mundaym): check pre-emption rules. +- +- e, _, _ := syscall_syscall(SYS___READDIR_R_A, dir, uintptr(unsafe.Pointer(&ent)), uintptr(unsafe.Pointer(&res))) +- var err error +- if e != 0 { +- err = errnoErr(Errno(e)) +- } +- if res == 0 { +- return nil, err +- } +- return &ent, err +-} +- +-func readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) { +- r0, _, e1 := syscall_syscall(SYS___READDIR_R_A, dirp, uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result))) +- if int64(r0) == -1 { +- err = errnoErr(Errno(e1)) ++func Opendir(name string) (uintptr, error) { ++ p, err := BytePtrFromString(name) ++ if err != nil { ++ return 0, err + } +- return ++ err = nil ++ runtime.EnterSyscall() ++ dir, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___OPENDIR_A<<4, uintptr(unsafe.Pointer(p))) ++ runtime.ExitSyscall() ++ runtime.KeepAlive(unsafe.Pointer(p)) ++ if dir == 0 { ++ err = errnoErr2(e1, e2) ++ } ++ return dir, err + } + ++// clearsyscall.Errno resets the errno value to 0. ++func clearErrno() ++ + func Closedir(dir uintptr) error { +- _, _, e := syscall_syscall(SYS_CLOSEDIR, dir, 0, 0) +- if e != 0 { +- return errnoErr(e) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSEDIR<<4, dir) ++ runtime.ExitSyscall() ++ if r0 != 0 { ++ return errnoErr2(e1, e2) + } + return nil + } + + func Seekdir(dir uintptr, pos int) { +- _, _, _ = syscall_syscall(SYS_SEEKDIR, dir, uintptr(pos), 0) ++ runtime.EnterSyscall() ++ CallLeFuncWithErr(GetZosLibVec()+SYS_SEEKDIR<<4, dir, uintptr(pos)) ++ runtime.ExitSyscall() + } + + func Telldir(dir uintptr) (int, error) { +- p, _, e := syscall_syscall(SYS_TELLDIR, dir, 0, 0) ++ p, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TELLDIR<<4, dir) + pos := int(p) +- if pos == -1 { +- return pos, errnoErr(e) ++ if int64(p) == -1 { ++ return pos, errnoErr2(e1, e2) + } + return pos, nil + } +@@ -1261,19 +2018,55 @@ func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { + *(*int64)(unsafe.Pointer(&flock[4])) = lk.Start + *(*int64)(unsafe.Pointer(&flock[12])) = lk.Len + *(*int32)(unsafe.Pointer(&flock[20])) = lk.Pid +- _, _, errno := syscall_syscall(SYS_FCNTL, fd, uintptr(cmd), uintptr(unsafe.Pointer(&flock))) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, fd, uintptr(cmd), uintptr(unsafe.Pointer(&flock))) ++ runtime.ExitSyscall() + lk.Type = *(*int16)(unsafe.Pointer(&flock[0])) + lk.Whence = *(*int16)(unsafe.Pointer(&flock[2])) + lk.Start = *(*int64)(unsafe.Pointer(&flock[4])) + lk.Len = *(*int64)(unsafe.Pointer(&flock[12])) + lk.Pid = *(*int32)(unsafe.Pointer(&flock[20])) +- if errno == 0 { ++ if r0 == 0 { + return nil + } +- return errno ++ return errnoErr2(e1, e2) ++} ++ ++func impl_Flock(fd int, how int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FLOCK<<4, uintptr(fd), uintptr(how)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FlockAddr() *(func(fd int, how int) (err error)) ++ ++var Flock = enter_Flock ++ ++func validFlock(fp uintptr) bool { ++ if funcptrtest(GetZosLibVec()+SYS_FLOCK<<4, "") == 0 { ++ if name, err := getLeFuncName(GetZosLibVec() + SYS_FLOCK<<4); err == nil { ++ return name == "flock" ++ } ++ } ++ return false ++} ++ ++func enter_Flock(fd int, how int) (err error) { ++ funcref := get_FlockAddr() ++ if validFlock(GetZosLibVec() + SYS_FLOCK<<4) { ++ *funcref = impl_Flock ++ } else { ++ *funcref = legacyFlock ++ } ++ return (*funcref)(fd, how) + } + +-func Flock(fd int, how int) error { ++func legacyFlock(fd int, how int) error { + + var flock_type int16 + var fcntl_cmd int +@@ -1307,41 +2100,51 @@ func Flock(fd int, how int) error { + } + + func Mlock(b []byte) (err error) { +- _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP) ++ runtime.ExitSyscall() ++ if r0 != 0 { ++ err = errnoErr2(e1, e2) + } + return + } + + func Mlock2(b []byte, flags int) (err error) { +- _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP) ++ runtime.ExitSyscall() ++ if r0 != 0 { ++ err = errnoErr2(e1, e2) + } + return + } + + func Mlockall(flags int) (err error) { +- _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP) ++ runtime.ExitSyscall() ++ if r0 != 0 { ++ err = errnoErr2(e1, e2) + } + return + } + + func Munlock(b []byte) (err error) { +- _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_SWAP, 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_SWAP) ++ runtime.ExitSyscall() ++ if r0 != 0 { ++ err = errnoErr2(e1, e2) + } + return + } + + func Munlockall() (err error) { +- _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_SWAP, 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_SWAP) ++ runtime.ExitSyscall() ++ if r0 != 0 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1372,15 +2175,104 @@ func ClockGettime(clockid int32, ts *Timespec) error { + return nil + } + +-func Statfs(path string, stat *Statfs_t) (err error) { +- fd, err := open(path, O_RDONLY, 0) +- defer Close(fd) +- if err != nil { +- return err ++// Chtag ++ ++//go:nosplit ++func get_ChtagAddr() *(func(path string, ccsid uint64, textbit uint64) error) ++ ++var Chtag = enter_Chtag ++ ++func enter_Chtag(path string, ccsid uint64, textbit uint64) error { ++ funcref := get_ChtagAddr() ++ if validSetxattr() { ++ *funcref = impl_Chtag ++ } else { ++ *funcref = legacy_Chtag ++ } ++ return (*funcref)(path, ccsid, textbit) ++} ++ ++func legacy_Chtag(path string, ccsid uint64, textbit uint64) error { ++ tag := ccsid<<16 | textbit<<15 ++ var tag_buff [8]byte ++ DecodeData(tag_buff[:], 8, tag) ++ return Setxattr(path, "filetag", tag_buff[:], XATTR_REPLACE) ++} ++ ++func impl_Chtag(path string, ccsid uint64, textbit uint64) error { ++ tag := ccsid<<16 | textbit<<15 ++ var tag_buff [4]byte ++ DecodeData(tag_buff[:], 4, tag) ++ return Setxattr(path, "system.filetag", tag_buff[:], XATTR_REPLACE) ++} ++ ++// End of Chtag ++ ++// Nanosleep ++ ++//go:nosplit ++func get_NanosleepAddr() *(func(time *Timespec, leftover *Timespec) error) ++ ++var Nanosleep = enter_Nanosleep ++ ++func enter_Nanosleep(time *Timespec, leftover *Timespec) error { ++ funcref := get_NanosleepAddr() ++ if funcptrtest(GetZosLibVec()+SYS_NANOSLEEP<<4, "") == 0 { ++ *funcref = impl_Nanosleep ++ } else { ++ *funcref = legacyNanosleep ++ } ++ return (*funcref)(time, leftover) ++} ++ ++func impl_Nanosleep(time *Timespec, leftover *Timespec) error { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_NANOSLEEP<<4, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ return errnoErr2(e1, e2) ++ } ++ return nil ++} ++ ++func legacyNanosleep(time *Timespec, leftover *Timespec) error { ++ t0 := runtime.Nanotime1() ++ var secrem uint32 ++ var nsecrem uint32 ++ total := time.Sec*1000000000 + time.Nsec ++ elapsed := runtime.Nanotime1() - t0 ++ var rv int32 ++ var rc int32 ++ var err error ++ // repeatedly sleep for 1 second until less than 1 second left ++ for total-elapsed > 1000000000 { ++ rv, rc, _ = BpxCondTimedWait(uint32(1), uint32(0), uint32(CW_CONDVAR), &secrem, &nsecrem) ++ if rv != 0 && rc != 112 { // 112 is EAGAIN ++ if leftover != nil && rc == 120 { // 120 is EINTR ++ leftover.Sec = int64(secrem) ++ leftover.Nsec = int64(nsecrem) ++ } ++ err = Errno(rc) ++ return err ++ } ++ elapsed = runtime.Nanotime1() - t0 + } +- return Fstatfs(fd, stat) ++ // sleep the remainder ++ if total > elapsed { ++ rv, rc, _ = BpxCondTimedWait(uint32(0), uint32(total-elapsed), uint32(CW_CONDVAR), &secrem, &nsecrem) ++ } ++ if leftover != nil && rc == 120 { ++ leftover.Sec = int64(secrem) ++ leftover.Nsec = int64(nsecrem) ++ } ++ if rv != 0 && rc != 112 { ++ err = Errno(rc) ++ } ++ return err + } + ++// End of Nanosleep ++ + var ( + Stdin = 0 + Stdout = 1 +@@ -1395,6 +2287,9 @@ var ( + errENOENT error = syscall.ENOENT + ) + ++var ZosTraceLevel int ++var ZosTracefile *os.File ++ + var ( + signalNameMapOnce sync.Once + signalNameMap map[string]syscall.Signal +@@ -1416,6 +2311,56 @@ func errnoErr(e Errno) error { + return e + } + ++var reg *regexp.Regexp ++ ++// enhanced with zos specific errno2 ++func errnoErr2(e Errno, e2 uintptr) error { ++ switch e { ++ case 0: ++ return nil ++ case EAGAIN: ++ return errEAGAIN ++ /* ++ Allow the retrieval of errno2 for EINVAL and ENOENT on zos ++ case EINVAL: ++ return errEINVAL ++ case ENOENT: ++ return errENOENT ++ */ ++ } ++ if ZosTraceLevel > 0 { ++ var name string ++ if reg == nil { ++ reg = regexp.MustCompile("(^unix\\.[^/]+$|.*\\/unix\\.[^/]+$)") ++ } ++ i := 1 ++ pc, file, line, ok := runtime.Caller(i) ++ if ok { ++ name = runtime.FuncForPC(pc).Name() ++ } ++ for ok && reg.MatchString(runtime.FuncForPC(pc).Name()) { ++ i += 1 ++ pc, file, line, ok = runtime.Caller(i) ++ } ++ if ok { ++ if ZosTracefile == nil { ++ ZosConsolePrintf("From %s:%d\n", file, line) ++ ZosConsolePrintf("%s: %s (errno2=0x%x)\n", name, e.Error(), e2) ++ } else { ++ fmt.Fprintf(ZosTracefile, "From %s:%d\n", file, line) ++ fmt.Fprintf(ZosTracefile, "%s: %s (errno2=0x%x)\n", name, e.Error(), e2) ++ } ++ } else { ++ if ZosTracefile == nil { ++ ZosConsolePrintf("%s (errno2=0x%x)\n", e.Error(), e2) ++ } else { ++ fmt.Fprintf(ZosTracefile, "%s (errno2=0x%x)\n", e.Error(), e2) ++ } ++ } ++ } ++ return e ++} ++ + // ErrnoName returns the error name for error number e. + func ErrnoName(e Errno) string { + i := sort.Search(len(errorList), func(i int) bool { +@@ -1474,6 +2419,9 @@ func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (d + return nil, EINVAL + } + ++ // Set __MAP_64 by default ++ flags |= __MAP_64 ++ + // Map the requested memory. + addr, errno := m.mmap(0, uintptr(length), prot, flags, fd, offset) + if errno != nil { +@@ -1778,83 +2726,170 @@ func Exec(argv0 string, argv []string, envv []string) error { + return syscall.Exec(argv0, argv, envv) + } + +-func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { ++func Getag(path string) (ccsid uint16, flag uint16, err error) { ++ var val [8]byte ++ sz, err := Getxattr(path, "ccsid", val[:]) ++ if err != nil { ++ return ++ } ++ ccsid = uint16(EncodeData(val[0:sz])) ++ sz, err = Getxattr(path, "flags", val[:]) ++ if err != nil { ++ return ++ } ++ flag = uint16(EncodeData(val[0:sz]) >> 15) ++ return ++} ++ ++// Mount begin ++func impl_Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(source) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(target) ++ if err != nil { ++ return ++ } ++ var _p2 *byte ++ _p2, err = BytePtrFromString(fstype) ++ if err != nil { ++ return ++ } ++ var _p3 *byte ++ _p3, err = BytePtrFromString(data) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MOUNT1_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(_p3))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_MountAddr() *(func(source string, target string, fstype string, flags uintptr, data string) (err error)) ++ ++var Mount = enter_Mount ++ ++func enter_Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { ++ funcref := get_MountAddr() ++ if validMount() { ++ *funcref = impl_Mount ++ } else { ++ *funcref = legacyMount ++ } ++ return (*funcref)(source, target, fstype, flags, data) ++} ++ ++func legacyMount(source string, target string, fstype string, flags uintptr, data string) (err error) { + if needspace := 8 - len(fstype); needspace <= 0 { +- fstype = fstype[:8] ++ fstype = fstype[0:8] + } else { +- fstype += " "[:needspace] ++ fstype += " "[0:needspace] + } + return mount_LE(target, source, fstype, uint32(flags), int32(len(data)), data) + } + +-func Unmount(name string, mtm int) (err error) { ++func validMount() bool { ++ if funcptrtest(GetZosLibVec()+SYS___MOUNT1_A<<4, "") == 0 { ++ if name, err := getLeFuncName(GetZosLibVec() + SYS___MOUNT1_A<<4); err == nil { ++ return name == "__mount1_a" ++ } ++ } ++ return false ++} ++ ++// Mount end ++ ++// Unmount begin ++func impl_Unmount(target string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(target) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UMOUNT2_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_UnmountAddr() *(func(target string, flags int) (err error)) ++ ++var Unmount = enter_Unmount ++ ++func enter_Unmount(target string, flags int) (err error) { ++ funcref := get_UnmountAddr() ++ if funcptrtest(GetZosLibVec()+SYS___UMOUNT2_A<<4, "") == 0 { ++ *funcref = impl_Unmount ++ } else { ++ *funcref = legacyUnmount ++ } ++ return (*funcref)(target, flags) ++} ++ ++func legacyUnmount(name string, mtm int) (err error) { + // mountpoint is always a full path and starts with a '/' + // check if input string is not a mountpoint but a filesystem name + if name[0] != '/' { +- return unmount(name, mtm) ++ return unmount_LE(name, mtm) + } + // treat name as mountpoint + b2s := func(arr []byte) string { +- nulli := bytes.IndexByte(arr, 0) +- if nulli == -1 { +- return string(arr) +- } else { +- return string(arr[:nulli]) ++ var str string ++ for i := 0; i < len(arr); i++ { ++ if arr[i] == 0 { ++ str = string(arr[:i]) ++ break ++ } + } ++ return str + } + var buffer struct { + header W_Mnth + fsinfo [64]W_Mntent + } +- fsCount, err := W_Getmntent_A((*byte)(unsafe.Pointer(&buffer)), int(unsafe.Sizeof(buffer))) +- if err != nil { +- return err +- } +- if fsCount == 0 { +- return EINVAL +- } +- for i := 0; i < fsCount; i++ { +- if b2s(buffer.fsinfo[i].Mountpoint[:]) == name { +- err = unmount(b2s(buffer.fsinfo[i].Fsname[:]), mtm) +- break ++ fs_count, err := W_Getmntent_A((*byte)(unsafe.Pointer(&buffer)), int(unsafe.Sizeof(buffer))) ++ if err == nil { ++ err = EINVAL ++ for i := 0; i < fs_count; i++ { ++ if b2s(buffer.fsinfo[i].Mountpoint[:]) == name { ++ err = unmount_LE(b2s(buffer.fsinfo[i].Fsname[:]), mtm) ++ break ++ } + } ++ } else if fs_count == 0 { ++ err = EINVAL + } + return err + } + +-func fdToPath(dirfd int) (path string, err error) { +- var buffer [1024]byte +- // w_ctrl() +- ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_W_IOCTL<<4, +- []uintptr{uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))}) +- if ret == 0 { +- zb := bytes.IndexByte(buffer[:], 0) +- if zb == -1 { +- zb = len(buffer) +- } +- // __e2a_l() +- runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, +- []uintptr{uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)}) +- return string(buffer[:zb]), nil +- } +- // __errno() +- errno := int(*(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, +- []uintptr{})))) +- // __errno2() +- errno2 := int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO2<<4, +- []uintptr{})) +- // strerror_r() +- ret = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_STRERROR_R<<4, +- []uintptr{uintptr(errno), uintptr(unsafe.Pointer(&buffer[0])), 1024}) +- if ret == 0 { +- zb := bytes.IndexByte(buffer[:], 0) +- if zb == -1 { +- zb = len(buffer) +- } +- return "", fmt.Errorf("%s (errno2=0x%x)", buffer[:zb], errno2) +- } else { +- return "", fmt.Errorf("fdToPath errno %d (errno2=0x%x)", errno, errno2) ++// Unmount end ++ ++func direntIno(buf []byte) (uint64, bool) { ++ return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) ++} ++ ++func direntReclen(buf []byte) (uint64, bool) { ++ return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) ++} ++ ++func direntNamlen(buf []byte) (uint64, bool) { ++ reclen, ok := direntReclen(buf) ++ if !ok { ++ return 0, false + } ++ return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true + } + + func direntLeToDirentUnix(dirent *direntLE, dir uintptr, path string) (Dirent, error) { +@@ -1896,7 +2931,7 @@ func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { + } + + // Get path from fd to avoid unavailable call (fdopendir) +- path, err := fdToPath(fd) ++ path, err := ZosFdToPath(fd) + if err != nil { + return 0, err + } +@@ -1910,7 +2945,7 @@ func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { + for { + var entryLE direntLE + var entrypLE *direntLE +- e := readdir_r(d, &entryLE, &entrypLE) ++ e := Readdir_r(d, &entryLE, &entrypLE) + if e != nil { + return n, e + } +@@ -1956,23 +2991,127 @@ func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { + return n, nil + } + +-func ReadDirent(fd int, buf []byte) (n int, err error) { +- var base = (*uintptr)(unsafe.Pointer(new(uint64))) +- return Getdirentries(fd, buf, base) ++func Err2ad() (eadd *int) { ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS___ERR2AD<<4) ++ eadd = (*int)(unsafe.Pointer(r0)) ++ return + } + +-func direntIno(buf []byte) (uint64, bool) { +- return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) ++func ZosConsolePrintf(format string, v ...interface{}) (int, error) { ++ type __cmsg struct { ++ _ uint16 ++ _ [2]uint8 ++ __msg_length uint32 ++ __msg uintptr ++ _ [4]uint8 ++ } ++ msg := fmt.Sprintf(format, v...) ++ strptr := unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&msg)).Data) ++ len := (*reflect.StringHeader)(unsafe.Pointer(&msg)).Len ++ cmsg := __cmsg{__msg_length: uint32(len), __msg: uintptr(strptr)} ++ cmd := uint32(0) ++ runtime.EnterSyscall() ++ rc, err2, err1 := CallLeFuncWithErr(GetZosLibVec()+SYS_____CONSOLE_A<<4, uintptr(unsafe.Pointer(&cmsg)), 0, uintptr(unsafe.Pointer(&cmd))) ++ runtime.ExitSyscall() ++ if rc != 0 { ++ return 0, fmt.Errorf("%s (errno2=0x%x)\n", err1.Error(), err2) ++ } ++ return 0, nil ++} ++func ZosStringToEbcdicBytes(str string, nullterm bool) (ebcdicBytes []byte) { ++ if nullterm { ++ ebcdicBytes = []byte(str + "\x00") ++ } else { ++ ebcdicBytes = []byte(str) ++ } ++ A2e(ebcdicBytes) ++ return ++} ++func ZosEbcdicBytesToString(b []byte, trimRight bool) (str string) { ++ res := make([]byte, len(b)) ++ copy(res, b) ++ E2a(res) ++ if trimRight { ++ str = string(bytes.TrimRight(res, " \x00")) ++ } else { ++ str = string(res) ++ } ++ return + } + +-func direntReclen(buf []byte) (uint64, bool) { +- return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) ++func fdToPath(dirfd int) (path string, err error) { ++ var buffer [1024]byte ++ // w_ctrl() ++ ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_W_IOCTL<<4, ++ []uintptr{uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))}) ++ if ret == 0 { ++ zb := bytes.IndexByte(buffer[:], 0) ++ if zb == -1 { ++ zb = len(buffer) ++ } ++ // __e2a_l() ++ runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, ++ []uintptr{uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)}) ++ return string(buffer[:zb]), nil ++ } ++ // __errno() ++ errno := int(*(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, ++ []uintptr{})))) ++ // __errno2() ++ errno2 := int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO2<<4, ++ []uintptr{})) ++ // strerror_r() ++ ret = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_STRERROR_R<<4, ++ []uintptr{uintptr(errno), uintptr(unsafe.Pointer(&buffer[0])), 1024}) ++ if ret == 0 { ++ zb := bytes.IndexByte(buffer[:], 0) ++ if zb == -1 { ++ zb = len(buffer) ++ } ++ return "", fmt.Errorf("%s (errno2=0x%x)", buffer[:zb], errno2) ++ } else { ++ return "", fmt.Errorf("fdToPath errno %d (errno2=0x%x)", errno, errno2) ++ } + } + +-func direntNamlen(buf []byte) (uint64, bool) { +- reclen, ok := direntReclen(buf) +- if !ok { +- return 0, false ++func impl_Mkfifoat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return + } +- return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKFIFOAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_MkfifoatAddr() *(func(dirfd int, path string, mode uint32) (err error)) ++ ++var Mkfifoat = enter_Mkfifoat ++ ++func enter_Mkfifoat(dirfd int, path string, mode uint32) (err error) { ++ funcref := get_MkfifoatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___MKFIFOAT_A<<4, "") == 0 { ++ *funcref = impl_Mkfifoat ++ } else { ++ *funcref = legacy_Mkfifoat ++ } ++ return (*funcref)(dirfd, path, mode) ++} ++ ++func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) { ++ dirname, err := ZosFdToPath(dirfd) ++ if err != nil { ++ return err ++ } ++ return Mkfifo(dirname+"/"+path, mode) + } ++ ++//sys Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT ++//sys Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT ++//sys Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT +diff --git a/vendor/golang.org/x/sys/unix/sysvshm_unix.go b/vendor/golang.org/x/sys/unix/sysvshm_unix.go +index 79a84f18b46d..672d6b0a8805 100644 +--- a/vendor/golang.org/x/sys/unix/sysvshm_unix.go ++++ b/vendor/golang.org/x/sys/unix/sysvshm_unix.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build (darwin && !ios) || linux ++//go:build (darwin && !ios) || linux || zos + + package unix + +diff --git a/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go b/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go +index 9eb0db664cbf..8b7977a28c06 100644 +--- a/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go ++++ b/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build darwin && !ios ++//go:build (darwin && !ios) || zos + + package unix + +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go +index 36bf8399f4fa..877a62b479a4 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go +@@ -491,6 +491,7 @@ const ( + BPF_F_REPLACE = 0x4 + BPF_F_SLEEPABLE = 0x10 + BPF_F_STRICT_ALIGNMENT = 0x1 ++ BPF_F_TEST_REG_INVARIANTS = 0x80 + BPF_F_TEST_RND_HI32 = 0x4 + BPF_F_TEST_RUN_ON_CPU = 0x1 + BPF_F_TEST_STATE_FREQ = 0x8 +@@ -501,6 +502,7 @@ const ( + BPF_IMM = 0x0 + BPF_IND = 0x40 + BPF_JA = 0x0 ++ BPF_JCOND = 0xe0 + BPF_JEQ = 0x10 + BPF_JGE = 0x30 + BPF_JGT = 0x20 +@@ -656,6 +658,9 @@ const ( + CAN_NPROTO = 0x8 + CAN_RAW = 0x1 + CAN_RAW_FILTER_MAX = 0x200 ++ CAN_RAW_XL_VCID_RX_FILTER = 0x4 ++ CAN_RAW_XL_VCID_TX_PASS = 0x2 ++ CAN_RAW_XL_VCID_TX_SET = 0x1 + CAN_RTR_FLAG = 0x40000000 + CAN_SFF_ID_BITS = 0xb + CAN_SFF_MASK = 0x7ff +@@ -1338,6 +1343,7 @@ const ( + F_OFD_SETLK = 0x25 + F_OFD_SETLKW = 0x26 + F_OK = 0x0 ++ F_SEAL_EXEC = 0x20 + F_SEAL_FUTURE_WRITE = 0x10 + F_SEAL_GROW = 0x4 + F_SEAL_SEAL = 0x1 +@@ -1626,6 +1632,7 @@ const ( + IP_FREEBIND = 0xf + IP_HDRINCL = 0x3 + IP_IPSEC_POLICY = 0x10 ++ IP_LOCAL_PORT_RANGE = 0x33 + IP_MAXPACKET = 0xffff + IP_MAX_MEMBERSHIPS = 0x14 + IP_MF = 0x2000 +@@ -1652,6 +1659,7 @@ const ( + IP_PMTUDISC_OMIT = 0x5 + IP_PMTUDISC_PROBE = 0x3 + IP_PMTUDISC_WANT = 0x1 ++ IP_PROTOCOL = 0x34 + IP_RECVERR = 0xb + IP_RECVERR_RFC4884 = 0x1a + IP_RECVFRAGSIZE = 0x19 +@@ -1697,6 +1705,7 @@ const ( + KEXEC_ARCH_S390 = 0x160000 + KEXEC_ARCH_SH = 0x2a0000 + KEXEC_ARCH_X86_64 = 0x3e0000 ++ KEXEC_FILE_DEBUG = 0x8 + KEXEC_FILE_NO_INITRAMFS = 0x4 + KEXEC_FILE_ON_CRASH = 0x2 + KEXEC_FILE_UNLOAD = 0x1 +@@ -1898,6 +1907,7 @@ const ( + MNT_DETACH = 0x2 + MNT_EXPIRE = 0x4 + MNT_FORCE = 0x1 ++ MNT_ID_REQ_SIZE_VER0 = 0x18 + MODULE_INIT_COMPRESSED_FILE = 0x4 + MODULE_INIT_IGNORE_MODVERSIONS = 0x1 + MODULE_INIT_IGNORE_VERMAGIC = 0x2 +@@ -2166,7 +2176,7 @@ const ( + NFT_SECMARK_CTX_MAXLEN = 0x100 + NFT_SET_MAXNAMELEN = 0x100 + NFT_SOCKET_MAX = 0x3 +- NFT_TABLE_F_MASK = 0x3 ++ NFT_TABLE_F_MASK = 0x7 + NFT_TABLE_MAXNAMELEN = 0x100 + NFT_TRACETYPE_MAX = 0x3 + NFT_TUNNEL_F_MASK = 0x7 +@@ -2302,6 +2312,7 @@ const ( + PERF_AUX_FLAG_PARTIAL = 0x4 + PERF_AUX_FLAG_PMU_FORMAT_TYPE_MASK = 0xff00 + PERF_AUX_FLAG_TRUNCATED = 0x1 ++ PERF_BRANCH_ENTRY_INFO_BITS_MAX = 0x21 + PERF_BR_ARM64_DEBUG_DATA = 0x7 + PERF_BR_ARM64_DEBUG_EXIT = 0x5 + PERF_BR_ARM64_DEBUG_HALT = 0x4 +@@ -2399,6 +2410,7 @@ const ( + PERF_RECORD_MISC_USER = 0x2 + PERF_SAMPLE_BRANCH_PLM_ALL = 0x7 + PERF_SAMPLE_WEIGHT_TYPE = 0x1004000 ++ PID_FS_MAGIC = 0x50494446 + PIPEFS_MAGIC = 0x50495045 + PPPIOCGNPMODE = 0xc008744c + PPPIOCNEWUNIT = 0xc004743e +@@ -2892,8 +2904,9 @@ const ( + RWF_APPEND = 0x10 + RWF_DSYNC = 0x2 + RWF_HIPRI = 0x1 ++ RWF_NOAPPEND = 0x20 + RWF_NOWAIT = 0x8 +- RWF_SUPPORTED = 0x1f ++ RWF_SUPPORTED = 0x3f + RWF_SYNC = 0x4 + RWF_WRITE_LIFE_NOT_SET = 0x0 + SCHED_BATCH = 0x3 +@@ -2914,7 +2927,9 @@ const ( + SCHED_RESET_ON_FORK = 0x40000000 + SCHED_RR = 0x2 + SCM_CREDENTIALS = 0x2 ++ SCM_PIDFD = 0x4 + SCM_RIGHTS = 0x1 ++ SCM_SECURITY = 0x3 + SCM_TIMESTAMP = 0x1d + SC_LOG_FLUSH = 0x100000 + SECCOMP_ADDFD_FLAG_SEND = 0x2 +@@ -3047,6 +3062,8 @@ const ( + SIOCSMIIREG = 0x8949 + SIOCSRARP = 0x8962 + SIOCWANDEV = 0x894a ++ SK_DIAG_BPF_STORAGE_MAX = 0x3 ++ SK_DIAG_BPF_STORAGE_REQ_MAX = 0x1 + SMACK_MAGIC = 0x43415d53 + SMART_AUTOSAVE = 0xd2 + SMART_AUTO_OFFLINE = 0xdb +@@ -3067,6 +3084,8 @@ const ( + SOCKFS_MAGIC = 0x534f434b + SOCK_BUF_LOCK_MASK = 0x3 + SOCK_DCCP = 0x6 ++ SOCK_DESTROY = 0x15 ++ SOCK_DIAG_BY_FAMILY = 0x14 + SOCK_IOC_TYPE = 0x89 + SOCK_PACKET = 0xa + SOCK_RAW = 0x3 +@@ -3168,6 +3187,7 @@ const ( + STATX_GID = 0x10 + STATX_INO = 0x100 + STATX_MNT_ID = 0x1000 ++ STATX_MNT_ID_UNIQUE = 0x4000 + STATX_MODE = 0x2 + STATX_MTIME = 0x40 + STATX_NLINK = 0x4 +@@ -3255,6 +3275,7 @@ const ( + TCP_MAX_WINSHIFT = 0xe + TCP_MD5SIG = 0xe + TCP_MD5SIG_EXT = 0x20 ++ TCP_MD5SIG_FLAG_IFINDEX = 0x2 + TCP_MD5SIG_FLAG_PREFIX = 0x1 + TCP_MD5SIG_MAXKEYLEN = 0x50 + TCP_MSS = 0x200 +@@ -3562,12 +3583,16 @@ const ( + XDP_RX_RING = 0x2 + XDP_SHARED_UMEM = 0x1 + XDP_STATISTICS = 0x7 ++ XDP_TXMD_FLAGS_CHECKSUM = 0x2 ++ XDP_TXMD_FLAGS_TIMESTAMP = 0x1 ++ XDP_TX_METADATA = 0x2 + XDP_TX_RING = 0x3 + XDP_UMEM_COMPLETION_RING = 0x6 + XDP_UMEM_FILL_RING = 0x5 + XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 + XDP_UMEM_PGOFF_FILL_RING = 0x100000000 + XDP_UMEM_REG = 0x4 ++ XDP_UMEM_TX_SW_CSUM = 0x2 + XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 + XDP_USE_NEED_WAKEUP = 0x8 + XDP_USE_SG = 0x10 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +index 42ff8c3c1b06..e4bc0bd57c7c 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +@@ -118,6 +118,7 @@ const ( + IXOFF = 0x1000 + IXON = 0x400 + MAP_32BIT = 0x40 ++ MAP_ABOVE4G = 0x80 + MAP_ANON = 0x20 + MAP_ANONYMOUS = 0x20 + MAP_DENYWRITE = 0x800 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +index dca436004fa4..689317afdbf3 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +@@ -118,6 +118,7 @@ const ( + IXOFF = 0x1000 + IXON = 0x400 + MAP_32BIT = 0x40 ++ MAP_ABOVE4G = 0x80 + MAP_ANON = 0x20 + MAP_ANONYMOUS = 0x20 + MAP_DENYWRITE = 0x800 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +index d8cae6d15340..14270508b040 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +@@ -87,6 +87,7 @@ const ( + FICLONE = 0x40049409 + FICLONERANGE = 0x4020940d + FLUSHO = 0x1000 ++ FPMR_MAGIC = 0x46504d52 + FPSIMD_MAGIC = 0x46508001 + FS_IOC_ENABLE_VERITY = 0x40806685 + FS_IOC_GETFLAGS = 0x80086601 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +index 4dfd2e051d35..da08b2ab3d93 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +@@ -10,41 +10,99 @@ + package unix + + const ( +- BRKINT = 0x0001 +- CLOCK_MONOTONIC = 0x1 +- CLOCK_PROCESS_CPUTIME_ID = 0x2 +- CLOCK_REALTIME = 0x0 +- CLOCK_THREAD_CPUTIME_ID = 0x3 +- CS8 = 0x0030 +- CSIZE = 0x0030 +- ECHO = 0x00000008 +- ECHONL = 0x00000001 +- FD_CLOEXEC = 0x01 +- FD_CLOFORK = 0x02 +- FNDELAY = 0x04 +- F_CLOSFD = 9 +- F_CONTROL_CVT = 13 +- F_DUPFD = 0 +- F_DUPFD2 = 8 +- F_GETFD = 1 +- F_GETFL = 259 +- F_GETLK = 5 +- F_GETOWN = 10 +- F_OK = 0x0 +- F_RDLCK = 1 +- F_SETFD = 2 +- F_SETFL = 4 +- F_SETLK = 6 +- F_SETLKW = 7 +- F_SETOWN = 11 +- F_SETTAG = 12 +- F_UNLCK = 3 +- F_WRLCK = 2 +- FSTYPE_ZFS = 0xe9 //"Z" +- FSTYPE_HFS = 0xc8 //"H" +- FSTYPE_NFS = 0xd5 //"N" +- FSTYPE_TFS = 0xe3 //"T" +- FSTYPE_AUTOMOUNT = 0xc1 //"A" ++ BRKINT = 0x0001 ++ CLOCAL = 0x1 ++ CLOCK_MONOTONIC = 0x1 ++ CLOCK_PROCESS_CPUTIME_ID = 0x2 ++ CLOCK_REALTIME = 0x0 ++ CLOCK_THREAD_CPUTIME_ID = 0x3 ++ CLONE_NEWIPC = 0x08000000 ++ CLONE_NEWNET = 0x40000000 ++ CLONE_NEWNS = 0x00020000 ++ CLONE_NEWPID = 0x20000000 ++ CLONE_NEWUTS = 0x04000000 ++ CLONE_PARENT = 0x00008000 ++ CS8 = 0x0030 ++ CSIZE = 0x0030 ++ ECHO = 0x00000008 ++ ECHONL = 0x00000001 ++ EFD_SEMAPHORE = 0x00002000 ++ EFD_CLOEXEC = 0x00001000 ++ EFD_NONBLOCK = 0x00000004 ++ EPOLL_CLOEXEC = 0x00001000 ++ EPOLL_CTL_ADD = 0 ++ EPOLL_CTL_MOD = 1 ++ EPOLL_CTL_DEL = 2 ++ EPOLLRDNORM = 0x0001 ++ EPOLLRDBAND = 0x0002 ++ EPOLLIN = 0x0003 ++ EPOLLOUT = 0x0004 ++ EPOLLWRBAND = 0x0008 ++ EPOLLPRI = 0x0010 ++ EPOLLERR = 0x0020 ++ EPOLLHUP = 0x0040 ++ EPOLLEXCLUSIVE = 0x20000000 ++ EPOLLONESHOT = 0x40000000 ++ FD_CLOEXEC = 0x01 ++ FD_CLOFORK = 0x02 ++ FD_SETSIZE = 0x800 ++ FNDELAY = 0x04 ++ F_CLOSFD = 9 ++ F_CONTROL_CVT = 13 ++ F_DUPFD = 0 ++ F_DUPFD2 = 8 ++ F_GETFD = 1 ++ F_GETFL = 259 ++ F_GETLK = 5 ++ F_GETOWN = 10 ++ F_OK = 0x0 ++ F_RDLCK = 1 ++ F_SETFD = 2 ++ F_SETFL = 4 ++ F_SETLK = 6 ++ F_SETLKW = 7 ++ F_SETOWN = 11 ++ F_SETTAG = 12 ++ F_UNLCK = 3 ++ F_WRLCK = 2 ++ FSTYPE_ZFS = 0xe9 //"Z" ++ FSTYPE_HFS = 0xc8 //"H" ++ FSTYPE_NFS = 0xd5 //"N" ++ FSTYPE_TFS = 0xe3 //"T" ++ FSTYPE_AUTOMOUNT = 0xc1 //"A" ++ GRND_NONBLOCK = 1 ++ GRND_RANDOM = 2 ++ HUPCL = 0x0100 // Hang up on last close ++ IN_CLOEXEC = 0x00001000 ++ IN_NONBLOCK = 0x00000004 ++ IN_ACCESS = 0x00000001 ++ IN_MODIFY = 0x00000002 ++ IN_ATTRIB = 0x00000004 ++ IN_CLOSE_WRITE = 0x00000008 ++ IN_CLOSE_NOWRITE = 0x00000010 ++ IN_OPEN = 0x00000020 ++ IN_MOVED_FROM = 0x00000040 ++ IN_MOVED_TO = 0x00000080 ++ IN_CREATE = 0x00000100 ++ IN_DELETE = 0x00000200 ++ IN_DELETE_SELF = 0x00000400 ++ IN_MOVE_SELF = 0x00000800 ++ IN_UNMOUNT = 0x00002000 ++ IN_Q_OVERFLOW = 0x00004000 ++ IN_IGNORED = 0x00008000 ++ IN_CLOSE = (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) ++ IN_MOVE = (IN_MOVED_FROM | IN_MOVED_TO) ++ IN_ALL_EVENTS = (IN_ACCESS | IN_MODIFY | IN_ATTRIB | ++ IN_CLOSE | IN_OPEN | IN_MOVE | ++ IN_CREATE | IN_DELETE | IN_DELETE_SELF | ++ IN_MOVE_SELF) ++ IN_ONLYDIR = 0x01000000 ++ IN_DONT_FOLLOW = 0x02000000 ++ IN_EXCL_UNLINK = 0x04000000 ++ IN_MASK_CREATE = 0x10000000 ++ IN_MASK_ADD = 0x20000000 ++ IN_ISDIR = 0x40000000 ++ IN_ONESHOT = 0x80000000 + IP6F_MORE_FRAG = 0x0001 + IP6F_OFF_MASK = 0xfff8 + IP6F_RESERVED_MASK = 0x0006 +@@ -152,10 +210,18 @@ const ( + IP_PKTINFO = 101 + IP_RECVPKTINFO = 102 + IP_TOS = 2 +- IP_TTL = 3 ++ IP_TTL = 14 + IP_UNBLOCK_SOURCE = 11 ++ ICMP6_FILTER = 1 ++ MCAST_INCLUDE = 0 ++ MCAST_EXCLUDE = 1 ++ MCAST_JOIN_GROUP = 40 ++ MCAST_LEAVE_GROUP = 41 ++ MCAST_JOIN_SOURCE_GROUP = 42 ++ MCAST_LEAVE_SOURCE_GROUP = 43 ++ MCAST_BLOCK_SOURCE = 44 ++ MCAST_UNBLOCK_SOURCE = 46 + ICANON = 0x0010 +- ICMP6_FILTER = 0x26 + ICRNL = 0x0002 + IEXTEN = 0x0020 + IGNBRK = 0x0004 +@@ -165,10 +231,10 @@ const ( + ISTRIP = 0x0080 + IXON = 0x0200 + IXOFF = 0x0100 +- LOCK_SH = 0x1 // Not exist on zOS +- LOCK_EX = 0x2 // Not exist on zOS +- LOCK_NB = 0x4 // Not exist on zOS +- LOCK_UN = 0x8 // Not exist on zOS ++ LOCK_SH = 0x1 ++ LOCK_EX = 0x2 ++ LOCK_NB = 0x4 ++ LOCK_UN = 0x8 + POLLIN = 0x0003 + POLLOUT = 0x0004 + POLLPRI = 0x0010 +@@ -182,15 +248,29 @@ const ( + MAP_PRIVATE = 0x1 // changes are private + MAP_SHARED = 0x2 // changes are shared + MAP_FIXED = 0x4 // place exactly +- MCAST_JOIN_GROUP = 40 +- MCAST_LEAVE_GROUP = 41 +- MCAST_JOIN_SOURCE_GROUP = 42 +- MCAST_LEAVE_SOURCE_GROUP = 43 +- MCAST_BLOCK_SOURCE = 44 +- MCAST_UNBLOCK_SOURCE = 45 ++ __MAP_MEGA = 0x8 ++ __MAP_64 = 0x10 ++ MAP_ANON = 0x20 ++ MAP_ANONYMOUS = 0x20 + MS_SYNC = 0x1 // msync - synchronous writes + MS_ASYNC = 0x2 // asynchronous writes + MS_INVALIDATE = 0x4 // invalidate mappings ++ MS_BIND = 0x00001000 ++ MS_MOVE = 0x00002000 ++ MS_NOSUID = 0x00000002 ++ MS_PRIVATE = 0x00040000 ++ MS_REC = 0x00004000 ++ MS_REMOUNT = 0x00008000 ++ MS_RDONLY = 0x00000001 ++ MS_UNBINDABLE = 0x00020000 ++ MNT_DETACH = 0x00000004 ++ ZOSDSFS_SUPER_MAGIC = 0x44534653 // zOS DSFS ++ NFS_SUPER_MAGIC = 0x6969 // NFS ++ NSFS_MAGIC = 0x6e736673 // PROCNS ++ PROC_SUPER_MAGIC = 0x9fa0 // proc FS ++ ZOSTFS_SUPER_MAGIC = 0x544653 // zOS TFS ++ ZOSUFS_SUPER_MAGIC = 0x554653 // zOS UFS ++ ZOSZFS_SUPER_MAGIC = 0x5A4653 // zOS ZFS + MTM_RDONLY = 0x80000000 + MTM_RDWR = 0x40000000 + MTM_UMOUNT = 0x10000000 +@@ -205,13 +285,20 @@ const ( + MTM_REMOUNT = 0x00000100 + MTM_NOSECURITY = 0x00000080 + NFDBITS = 0x20 ++ ONLRET = 0x0020 // NL performs CR function + O_ACCMODE = 0x03 + O_APPEND = 0x08 + O_ASYNCSIG = 0x0200 + O_CREAT = 0x80 ++ O_DIRECT = 0x00002000 ++ O_NOFOLLOW = 0x00004000 ++ O_DIRECTORY = 0x00008000 ++ O_PATH = 0x00080000 ++ O_CLOEXEC = 0x00001000 + O_EXCL = 0x40 + O_GETFL = 0x0F + O_LARGEFILE = 0x0400 ++ O_NDELAY = 0x4 + O_NONBLOCK = 0x04 + O_RDONLY = 0x02 + O_RDWR = 0x03 +@@ -248,6 +335,7 @@ const ( + AF_IUCV = 17 + AF_LAT = 14 + AF_LINK = 18 ++ AF_LOCAL = AF_UNIX // AF_LOCAL is an alias for AF_UNIX + AF_MAX = 30 + AF_NBS = 7 + AF_NDD = 23 +@@ -285,15 +373,33 @@ const ( + RLIMIT_AS = 5 + RLIMIT_NOFILE = 6 + RLIMIT_MEMLIMIT = 7 ++ RLIMIT_MEMLOCK = 0x8 + RLIM_INFINITY = 2147483647 ++ SCHED_FIFO = 0x2 ++ SCM_CREDENTIALS = 0x2 + SCM_RIGHTS = 0x01 + SF_CLOSE = 0x00000002 + SF_REUSE = 0x00000001 ++ SHM_RND = 0x2 ++ SHM_RDONLY = 0x1 ++ SHMLBA = 0x1000 ++ IPC_STAT = 0x3 ++ IPC_SET = 0x2 ++ IPC_RMID = 0x1 ++ IPC_PRIVATE = 0x0 ++ IPC_CREAT = 0x1000000 ++ __IPC_MEGA = 0x4000000 ++ __IPC_SHAREAS = 0x20000000 ++ __IPC_BELOWBAR = 0x10000000 ++ IPC_EXCL = 0x2000000 ++ __IPC_GIGA = 0x8000000 + SHUT_RD = 0 + SHUT_RDWR = 2 + SHUT_WR = 1 ++ SOCK_CLOEXEC = 0x00001000 + SOCK_CONN_DGRAM = 6 + SOCK_DGRAM = 2 ++ SOCK_NONBLOCK = 0x800 + SOCK_RAW = 3 + SOCK_RDM = 4 + SOCK_SEQPACKET = 5 +@@ -378,8 +484,6 @@ const ( + S_IFMST = 0x00FF0000 + TCP_KEEPALIVE = 0x8 + TCP_NODELAY = 0x1 +- TCP_INFO = 0xb +- TCP_USER_TIMEOUT = 0x1 + TIOCGWINSZ = 0x4008a368 + TIOCSWINSZ = 0x8008a367 + TIOCSBRK = 0x2000a77b +@@ -427,7 +531,10 @@ const ( + VSUSP = 9 + VTIME = 10 + WCONTINUED = 0x4 ++ WEXITED = 0x8 + WNOHANG = 0x1 ++ WNOWAIT = 0x20 ++ WSTOPPED = 0x10 + WUNTRACED = 0x2 + _BPX_SWAP = 1 + _BPX_NONSWAP = 2 +@@ -452,8 +559,28 @@ const ( + MADV_FREE = 15 // for Linux compatibility -- no zos semantics + MADV_WIPEONFORK = 16 // for Linux compatibility -- no zos semantics + MADV_KEEPONFORK = 17 // for Linux compatibility -- no zos semantics +- AT_SYMLINK_NOFOLLOW = 1 // for Unix compatibility -- no zos semantics +- AT_FDCWD = 2 // for Unix compatibility -- no zos semantics ++ AT_SYMLINK_FOLLOW = 0x400 ++ AT_SYMLINK_NOFOLLOW = 0x100 ++ XATTR_CREATE = 0x1 ++ XATTR_REPLACE = 0x2 ++ P_PID = 0 ++ P_PGID = 1 ++ P_ALL = 2 ++ PR_SET_NAME = 15 ++ PR_GET_NAME = 16 ++ PR_SET_NO_NEW_PRIVS = 38 ++ PR_GET_NO_NEW_PRIVS = 39 ++ PR_SET_DUMPABLE = 4 ++ PR_GET_DUMPABLE = 3 ++ PR_SET_PDEATHSIG = 1 ++ PR_GET_PDEATHSIG = 2 ++ PR_SET_CHILD_SUBREAPER = 36 ++ PR_GET_CHILD_SUBREAPER = 37 ++ AT_FDCWD = -100 ++ AT_EACCESS = 0x200 ++ AT_EMPTY_PATH = 0x1000 ++ AT_REMOVEDIR = 0x200 ++ RENAME_NOREPLACE = 1 << 0 + ) + + const ( +@@ -476,6 +603,7 @@ const ( + EMLINK = Errno(125) + ENAMETOOLONG = Errno(126) + ENFILE = Errno(127) ++ ENOATTR = Errno(265) + ENODEV = Errno(128) + ENOENT = Errno(129) + ENOEXEC = Errno(130) +@@ -700,7 +828,7 @@ var errorList = [...]struct { + {145, "EDC5145I", "The parameter list is too long, or the message to receive was too large for the buffer."}, + {146, "EDC5146I", "Too many levels of symbolic links."}, + {147, "EDC5147I", "Illegal byte sequence."}, +- {148, "", ""}, ++ {148, "EDC5148I", "The named attribute or data not available."}, + {149, "EDC5149I", "Value Overflow Error."}, + {150, "EDC5150I", "UNIX System Services is not active."}, + {151, "EDC5151I", "Dynamic allocation error."}, +@@ -743,6 +871,7 @@ var errorList = [...]struct { + {259, "EDC5259I", "A CUN_RS_NO_CONVERSION error was issued by Unicode Services."}, + {260, "EDC5260I", "A CUN_RS_TABLE_NOT_ALIGNED error was issued by Unicode Services."}, + {262, "EDC5262I", "An iconv() function encountered an unexpected error while using Unicode Services."}, ++ {265, "EDC5265I", "The named attribute not available."}, + {1000, "EDC8000I", "A bad socket-call constant was found in the IUCV header."}, + {1001, "EDC8001I", "An error was found in the IUCV header."}, + {1002, "EDC8002I", "A socket descriptor is out of range."}, +diff --git a/vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s b/vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s +new file mode 100644 +index 000000000000..b77ff5db90d5 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s +@@ -0,0 +1,364 @@ ++// go run mksyscall_zos_s390x.go -o_sysnum zsysnum_zos_s390x.go -o_syscall zsyscall_zos_s390x.go -i_syscall syscall_zos_s390x.go -o_asm zsymaddr_zos_s390x.s ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build zos && s390x ++#include "textflag.h" ++ ++// provide the address of function variable to be fixed up. ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FlistxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Flistxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FremovexattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fremovexattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FgetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fgetxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FsetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fsetxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_accept4Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·accept4(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_RemovexattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Removexattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_Dup3Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Dup3(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_DirfdAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Dirfd(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_EpollCreateAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·EpollCreate(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_EpollCreate1Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·EpollCreate1(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_EpollCtlAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·EpollCtl(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_EpollPwaitAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·EpollPwait(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_EpollWaitAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·EpollWait(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_EventfdAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Eventfd(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FaccessatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Faccessat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FchmodatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fchmodat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FchownatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fchownat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FdatasyncAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fdatasync(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_fstatatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·fstatat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_LgetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Lgetxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_LsetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Lsetxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FstatfsAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Fstatfs(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FutimesAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Futimes(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_FutimesatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Futimesat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_GetrandomAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Getrandom(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_InotifyInitAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·InotifyInit(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_InotifyInit1Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·InotifyInit1(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_InotifyAddWatchAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·InotifyAddWatch(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_InotifyRmWatchAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·InotifyRmWatch(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_ListxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Listxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_LlistxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Llistxattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_LremovexattrAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Lremovexattr(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_LutimesAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Lutimes(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_StatfsAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Statfs(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_SyncfsAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Syncfs(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_UnshareAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Unshare(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_LinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Linkat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_MkdiratAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Mkdirat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_MknodatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Mknodat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_PivotRootAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·PivotRoot(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_PrctlAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Prctl(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_PrlimitAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Prlimit(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_RenameatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Renameat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_Renameat2Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Renameat2(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_SethostnameAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Sethostname(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_SetnsAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Setns(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_SymlinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Symlinkat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_UnlinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·Unlinkat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_openatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·openat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_openat2Addr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·openat2(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++TEXT ·get_utimensatAddr(SB), NOSPLIT|NOFRAME, $0-8 ++ MOVD $·utimensat(SB), R8 ++ MOVD R8, ret+0(FP) ++ RET +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +index 1488d27128cd..87d8612a1dc7 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +@@ -906,6 +906,16 @@ func Fspick(dirfd int, pathName string, flags int) (fd int, err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func fsconfig(fd int, cmd uint, key *byte, value *byte, aux int) (err error) { ++ _, _, e1 := Syscall6(SYS_FSCONFIG, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(value)), uintptr(aux), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func Getdents(fd int, buf []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(buf) > 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go +index 94f011238319..7ccf66b7ee0d 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go +@@ -1,4 +1,4 @@ +-// go run mksyscall.go -tags zos,s390x syscall_zos_s390x.go ++// go run mksyscall_zos_s390x.go -o_sysnum zsysnum_zos_s390x.go -o_syscall zsyscall_zos_s390x.go -i_syscall syscall_zos_s390x.go -o_asm zsymaddr_zos_s390x.s + // Code generated by the command above; see README.md. DO NOT EDIT. + + //go:build zos && s390x +@@ -6,17 +6,100 @@ + package unix + + import ( ++ "runtime" ++ "syscall" + "unsafe" + ) + ++var _ syscall.Errno ++ + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func fcntl(fd int, cmd int, arg int) (val int, err error) { +- r0, _, e1 := syscall_syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), uintptr(arg)) ++ runtime.ExitSyscall() + val = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Flistxattr(fd int, dest []byte) (sz int, err error) { ++ var _p0 unsafe.Pointer ++ if len(dest) > 0 { ++ _p0 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FLISTXATTR_A<<4, uintptr(fd), uintptr(_p0), uintptr(len(dest))) ++ runtime.ExitSyscall() ++ sz = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FlistxattrAddr() *(func(fd int, dest []byte) (sz int, err error)) ++ ++var Flistxattr = enter_Flistxattr ++ ++func enter_Flistxattr(fd int, dest []byte) (sz int, err error) { ++ funcref := get_FlistxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FLISTXATTR_A<<4, "") == 0 { ++ *funcref = impl_Flistxattr ++ } else { ++ *funcref = error_Flistxattr ++ } ++ return (*funcref)(fd, dest) ++} ++ ++func error_Flistxattr(fd int, dest []byte) (sz int, err error) { ++ sz = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Fremovexattr(fd int, attr string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FREMOVEXATTR_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FremovexattrAddr() *(func(fd int, attr string) (err error)) ++ ++var Fremovexattr = enter_Fremovexattr ++ ++func enter_Fremovexattr(fd int, attr string) (err error) { ++ funcref := get_FremovexattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FREMOVEXATTR_A<<4, "") == 0 { ++ *funcref = impl_Fremovexattr ++ } else { ++ *funcref = error_Fremovexattr + } ++ return (*funcref)(fd, attr) ++} ++ ++func error_Fremovexattr(fd int, attr string) (err error) { ++ err = ENOSYS + return + } + +@@ -29,10 +112,12 @@ func read(fd int, p []byte) (n int, err error) { + } else { + _p0 = unsafe.Pointer(&_zero) + } +- r0, _, e1 := syscall_syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_READ<<4, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ runtime.ExitSyscall() + n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -46,31 +131,159 @@ func write(fd int, p []byte) (n int, err error) { + } else { + _p0 = unsafe.Pointer(&_zero) + } +- r0, _, e1 := syscall_syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WRITE<<4, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ runtime.ExitSyscall() + n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FGETXATTR_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) ++ runtime.ExitSyscall() ++ sz = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FgetxattrAddr() *(func(fd int, attr string, dest []byte) (sz int, err error)) ++ ++var Fgetxattr = enter_Fgetxattr ++ ++func enter_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { ++ funcref := get_FgetxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FGETXATTR_A<<4, "") == 0 { ++ *funcref = impl_Fgetxattr ++ } else { ++ *funcref = error_Fgetxattr ++ } ++ return (*funcref)(fd, attr, dest) ++} ++ ++func error_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { ++ sz = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Fsetxattr(fd int, attr string, data []byte, flag int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(data) > 0 { ++ _p1 = unsafe.Pointer(&data[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FSETXATTR_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(data)), uintptr(flag)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FsetxattrAddr() *(func(fd int, attr string, data []byte, flag int) (err error)) ++ ++var Fsetxattr = enter_Fsetxattr ++ ++func enter_Fsetxattr(fd int, attr string, data []byte, flag int) (err error) { ++ funcref := get_FsetxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FSETXATTR_A<<4, "") == 0 { ++ *funcref = impl_Fsetxattr ++ } else { ++ *funcref = error_Fsetxattr + } ++ return (*funcref)(fd, attr, data, flag) ++} ++ ++func error_Fsetxattr(fd int, attr string, data []byte, flag int) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { +- r0, _, e1 := syscall_syscall(SYS___ACCEPT_A, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___ACCEPT_A<<4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___ACCEPT4_A<<4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags)) ++ runtime.ExitSyscall() + fd = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_accept4Addr() *(func(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error)) ++ ++var accept4 = enter_accept4 ++ ++func enter_accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { ++ funcref := get_accept4Addr() ++ if funcptrtest(GetZosLibVec()+SYS___ACCEPT4_A<<4, "") == 0 { ++ *funcref = impl_accept4 ++ } else { ++ *funcref = error_accept4 + } ++ return (*funcref)(s, rsa, addrlen, flags) ++} ++ ++func error_accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { +- _, _, e1 := syscall_syscall(SYS___BIND_A, uintptr(s), uintptr(addr), uintptr(addrlen)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___BIND_A<<4, uintptr(s), uintptr(addr), uintptr(addrlen)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -78,9 +291,11 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { +- _, _, e1 := syscall_syscall(SYS___CONNECT_A, uintptr(s), uintptr(addr), uintptr(addrlen)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CONNECT_A<<4, uintptr(s), uintptr(addr), uintptr(addrlen)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -88,10 +303,10 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func getgroups(n int, list *_Gid_t) (nn int, err error) { +- r0, _, e1 := syscall_rawsyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETGROUPS<<4, uintptr(n), uintptr(unsafe.Pointer(list))) + nn = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -99,9 +314,9 @@ func getgroups(n int, list *_Gid_t) (nn int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func setgroups(n int, list *_Gid_t) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETGROUPS<<4, uintptr(n), uintptr(unsafe.Pointer(list))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -109,9 +324,11 @@ func setgroups(n int, list *_Gid_t) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { +- _, _, e1 := syscall_syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETSOCKOPT<<4, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -119,9 +336,11 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { +- _, _, e1 := syscall_syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETSOCKOPT<<4, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -129,10 +348,10 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func socket(domain int, typ int, proto int) (fd int, err error) { +- r0, _, e1 := syscall_rawsyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto)) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SOCKET<<4, uintptr(domain), uintptr(typ), uintptr(proto)) + fd = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -140,9 +359,9 @@ func socket(domain int, typ int, proto int) (fd int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { +- _, _, e1 := syscall_rawsyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SOCKETPAIR<<4, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -150,9 +369,9 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS___GETPEERNAME_A, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETPEERNAME_A<<4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -160,10 +379,52 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS___GETSOCKNAME_A, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETSOCKNAME_A<<4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Removexattr(path string, attr string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___REMOVEXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_RemovexattrAddr() *(func(path string, attr string) (err error)) ++ ++var Removexattr = enter_Removexattr ++ ++func enter_Removexattr(path string, attr string) (err error) { ++ funcref := get_RemovexattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___REMOVEXATTR_A<<4, "") == 0 { ++ *funcref = impl_Removexattr ++ } else { ++ *funcref = error_Removexattr + } ++ return (*funcref)(path, attr) ++} ++ ++func error_Removexattr(path string, attr string) (err error) { ++ err = ENOSYS + return + } + +@@ -176,10 +437,12 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl + } else { + _p0 = unsafe.Pointer(&_zero) + } +- r0, _, e1 := syscall_syscall6(SYS___RECVFROM_A, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RECVFROM_A<<4, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) ++ runtime.ExitSyscall() + n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -193,9 +456,11 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) ( + } else { + _p0 = unsafe.Pointer(&_zero) + } +- _, _, e1 := syscall_syscall6(SYS___SENDTO_A, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SENDTO_A<<4, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -203,10 +468,12 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) ( + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { +- r0, _, e1 := syscall_syscall(SYS___RECVMSG_A, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RECVMSG_A<<4, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ runtime.ExitSyscall() + n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -214,10 +481,12 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { +- r0, _, e1 := syscall_syscall(SYS___SENDMSG_A, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SENDMSG_A<<4, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ runtime.ExitSyscall() + n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -225,10 +494,12 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { +- r0, _, e1 := syscall_syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MMAP<<4, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos)) ++ runtime.ExitSyscall() + ret = uintptr(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -236,9 +507,11 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) ( + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func munmap(addr uintptr, length uintptr) (err error) { +- _, _, e1 := syscall_syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MUNMAP<<4, uintptr(addr), uintptr(length)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -246,9 +519,11 @@ func munmap(addr uintptr, length uintptr) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func ioctl(fd int, req int, arg uintptr) (err error) { +- _, _, e1 := syscall_syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_IOCTL<<4, uintptr(fd), uintptr(req), uintptr(arg)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -256,9 +531,62 @@ func ioctl(fd int, req int, arg uintptr) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func ioctlPtr(fd int, req int, arg unsafe.Pointer) (err error) { +- _, _, e1 := syscall_syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_IOCTL<<4, uintptr(fd), uintptr(req), uintptr(arg)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmat(id int, addr uintptr, flag int) (ret uintptr, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMAT<<4, uintptr(id), uintptr(addr), uintptr(flag)) ++ runtime.ExitSyscall() ++ ret = uintptr(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMCTL64<<4, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf))) ++ runtime.ExitSyscall() ++ result = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmdt(addr uintptr) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMDT<<4, uintptr(addr)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmget(key int, size int, flag int) (id int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMGET<<4, uintptr(key), uintptr(size), uintptr(flag)) ++ runtime.ExitSyscall() ++ id = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -271,9 +599,11 @@ func Access(path string, mode uint32) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___ACCESS_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___ACCESS_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -286,9 +616,11 @@ func Chdir(path string) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___CHDIR_A, uintptr(unsafe.Pointer(_p0)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHDIR_A<<4, uintptr(unsafe.Pointer(_p0))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -301,9 +633,11 @@ func Chown(path string, uid int, gid int) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___CHOWN_A, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHOWN_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -316,9 +650,11 @@ func Chmod(path string, mode uint32) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___CHMOD_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHMOD_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -331,10 +667,12 @@ func Creat(path string, mode uint32) (fd int, err error) { + if err != nil { + return + } +- r0, _, e1 := syscall_syscall(SYS___CREAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CREAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() + fd = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -342,10 +680,12 @@ func Creat(path string, mode uint32) (fd int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Dup(oldfd int) (fd int, err error) { +- r0, _, e1 := syscall_syscall(SYS_DUP, uintptr(oldfd), 0, 0) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DUP<<4, uintptr(oldfd)) ++ runtime.ExitSyscall() + fd = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -353,617 +693,2216 @@ func Dup(oldfd int) (fd int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Dup2(oldfd int, newfd int) (err error) { +- _, _, e1 := syscall_syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DUP2<<4, uintptr(oldfd), uintptr(newfd)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Errno2() (er2 int) { +- uer2, _, _ := syscall_syscall(SYS___ERRNO2, 0, 0, 0) +- er2 = int(uer2) ++func impl_Dup3(oldfd int, newfd int, flags int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DUP3<<4, uintptr(oldfd), uintptr(newfd), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_Dup3Addr() *(func(oldfd int, newfd int, flags int) (err error)) + +-func Err2ad() (eadd *int) { +- ueadd, _, _ := syscall_syscall(SYS___ERR2AD, 0, 0, 0) +- eadd = (*int)(unsafe.Pointer(ueadd)) +- return +-} ++var Dup3 = enter_Dup3 + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++func enter_Dup3(oldfd int, newfd int, flags int) (err error) { ++ funcref := get_Dup3Addr() ++ if funcptrtest(GetZosLibVec()+SYS_DUP3<<4, "") == 0 { ++ *funcref = impl_Dup3 ++ } else { ++ *funcref = error_Dup3 ++ } ++ return (*funcref)(oldfd, newfd, flags) ++} + +-func Exit(code int) { +- syscall_syscall(SYS_EXIT, uintptr(code), 0, 0) ++func error_Dup3(oldfd int, newfd int, flags int) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Fchdir(fd int) (err error) { +- _, _, e1 := syscall_syscall(SYS_FCHDIR, uintptr(fd), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_Dirfd(dirp uintptr) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DIRFD<<4, uintptr(dirp)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_DirfdAddr() *(func(dirp uintptr) (fd int, err error)) + +-func Fchmod(fd int, mode uint32) (err error) { +- _, _, e1 := syscall_syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var Dirfd = enter_Dirfd ++ ++func enter_Dirfd(dirp uintptr) (fd int, err error) { ++ funcref := get_DirfdAddr() ++ if funcptrtest(GetZosLibVec()+SYS_DIRFD<<4, "") == 0 { ++ *funcref = impl_Dirfd ++ } else { ++ *funcref = error_Dirfd + } ++ return (*funcref)(dirp) ++} ++ ++func error_Dirfd(dirp uintptr) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Fchown(fd int, uid int, gid int) (err error) { +- _, _, e1 := syscall_syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid)) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_EpollCreate(size int) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_CREATE<<4, uintptr(size)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_EpollCreateAddr() *(func(size int) (fd int, err error)) + +-func FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) { +- r0, _, e1 := syscall_syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg)) +- retval = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++var EpollCreate = enter_EpollCreate ++ ++func enter_EpollCreate(size int) (fd int, err error) { ++ funcref := get_EpollCreateAddr() ++ if funcptrtest(GetZosLibVec()+SYS_EPOLL_CREATE<<4, "") == 0 { ++ *funcref = impl_EpollCreate ++ } else { ++ *funcref = error_EpollCreate + } ++ return (*funcref)(size) ++} ++ ++func error_EpollCreate(size int) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func fstat(fd int, stat *Stat_LE_t) (err error) { +- _, _, e1 := syscall_syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_EpollCreate1(flags int) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_CREATE1<<4, uintptr(flags)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_EpollCreate1Addr() *(func(flags int) (fd int, err error)) + +-func Fstatvfs(fd int, stat *Statvfs_t) (err error) { +- _, _, e1 := syscall_syscall(SYS_FSTATVFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var EpollCreate1 = enter_EpollCreate1 ++ ++func enter_EpollCreate1(flags int) (fd int, err error) { ++ funcref := get_EpollCreate1Addr() ++ if funcptrtest(GetZosLibVec()+SYS_EPOLL_CREATE1<<4, "") == 0 { ++ *funcref = impl_EpollCreate1 ++ } else { ++ *funcref = error_EpollCreate1 + } ++ return (*funcref)(flags) ++} ++ ++func error_EpollCreate1(flags int) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Fsync(fd int) (err error) { +- _, _, e1 := syscall_syscall(SYS_FSYNC, uintptr(fd), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_CTL<<4, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_EpollCtlAddr() *(func(epfd int, op int, fd int, event *EpollEvent) (err error)) + +-func Ftruncate(fd int, length int64) (err error) { +- _, _, e1 := syscall_syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var EpollCtl = enter_EpollCtl ++ ++func enter_EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { ++ funcref := get_EpollCtlAddr() ++ if funcptrtest(GetZosLibVec()+SYS_EPOLL_CTL<<4, "") == 0 { ++ *funcref = impl_EpollCtl ++ } else { ++ *funcref = error_EpollCtl + } +- return ++ return (*funcref)(epfd, op, fd, event) + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- +-func Getpagesize() (pgsize int) { +- r0, _, _ := syscall_syscall(SYS_GETPAGESIZE, 0, 0, 0) +- pgsize = int(r0) ++func error_EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Mprotect(b []byte, prot int) (err error) { ++func impl_EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) { + var _p0 unsafe.Pointer +- if len(b) > 0 { +- _p0 = unsafe.Pointer(&b[0]) ++ if len(events) > 0 { ++ _p0 = unsafe.Pointer(&events[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } +- _, _, e1 := syscall_syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_PWAIT<<4, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), uintptr(unsafe.Pointer(sigmask))) ++ runtime.ExitSyscall() ++ n = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_EpollPwaitAddr() *(func(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error)) + +-func Msync(b []byte, flags int) (err error) { +- var _p0 unsafe.Pointer +- if len(b) > 0 { +- _p0 = unsafe.Pointer(&b[0]) ++var EpollPwait = enter_EpollPwait ++ ++func enter_EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) { ++ funcref := get_EpollPwaitAddr() ++ if funcptrtest(GetZosLibVec()+SYS_EPOLL_PWAIT<<4, "") == 0 { ++ *funcref = impl_EpollPwait + } else { +- _p0 = unsafe.Pointer(&_zero) +- } +- _, _, e1 := syscall_syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags)) +- if e1 != 0 { +- err = errnoErr(e1) ++ *funcref = error_EpollPwait + } ++ return (*funcref)(epfd, events, msec, sigmask) ++} ++ ++func error_EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) { ++ n = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Poll(fds []PollFd, timeout int) (n int, err error) { ++func impl_EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { + var _p0 unsafe.Pointer +- if len(fds) > 0 { +- _p0 = unsafe.Pointer(&fds[0]) ++ if len(events) > 0 { ++ _p0 = unsafe.Pointer(&events[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } +- r0, _, e1 := syscall_syscall(SYS_POLL, uintptr(_p0), uintptr(len(fds)), uintptr(timeout)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_WAIT<<4, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec)) ++ runtime.ExitSyscall() + n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_EpollWaitAddr() *(func(epfd int, events []EpollEvent, msec int) (n int, err error)) + +-func Times(tms *Tms) (ticks uintptr, err error) { +- r0, _, e1 := syscall_syscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0) +- ticks = uintptr(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++var EpollWait = enter_EpollWait ++ ++func enter_EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { ++ funcref := get_EpollWaitAddr() ++ if funcptrtest(GetZosLibVec()+SYS_EPOLL_WAIT<<4, "") == 0 { ++ *funcref = impl_EpollWait ++ } else { ++ *funcref = error_EpollWait + } ++ return (*funcref)(epfd, events, msec) ++} ++ ++func error_EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { ++ n = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func W_Getmntent(buff *byte, size int) (lastsys int, err error) { +- r0, _, e1 := syscall_syscall(SYS_W_GETMNTENT, uintptr(unsafe.Pointer(buff)), uintptr(size), 0) +- lastsys = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } ++func Errno2() (er2 int) { ++ runtime.EnterSyscall() ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS___ERRNO2<<4) ++ runtime.ExitSyscall() ++ er2 = int(r0) + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func W_Getmntent_A(buff *byte, size int) (lastsys int, err error) { +- r0, _, e1 := syscall_syscall(SYS___W_GETMNTENT_A, uintptr(unsafe.Pointer(buff)), uintptr(size), 0) +- lastsys = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_Eventfd(initval uint, flags int) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EVENTFD<<4, uintptr(initval), uintptr(flags)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + ++//go:nosplit ++func get_EventfdAddr() *(func(initval uint, flags int) (fd int, err error)) ++ ++var Eventfd = enter_Eventfd ++ ++func enter_Eventfd(initval uint, flags int) (fd int, err error) { ++ funcref := get_EventfdAddr() ++ if funcptrtest(GetZosLibVec()+SYS_EVENTFD<<4, "") == 0 { ++ *funcref = impl_Eventfd ++ } else { ++ *funcref = error_Eventfd ++ } ++ return (*funcref)(initval, flags) ++} ++ ++func error_Eventfd(initval uint, flags int) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS ++ return ++} ++ + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) { ++func Exit(code int) { ++ runtime.EnterSyscall() ++ CallLeFuncWithErr(GetZosLibVec()+SYS_EXIT<<4, uintptr(code)) ++ runtime.ExitSyscall() ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } +- var _p1 *byte +- _p1, err = BytePtrFromString(filesystem) +- if err != nil { +- return +- } +- var _p2 *byte +- _p2, err = BytePtrFromString(fstype) +- if err != nil { +- return +- } +- var _p3 *byte +- _p3, err = BytePtrFromString(parm) +- if err != nil { +- return +- } +- _, _, e1 := syscall_syscall6(SYS___MOUNT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(mtm), uintptr(parmlen), uintptr(unsafe.Pointer(_p3))) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FACCESSAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_FaccessatAddr() *(func(dirfd int, path string, mode uint32, flags int) (err error)) + +-func unmount(filesystem string, mtm int) (err error) { ++var Faccessat = enter_Faccessat ++ ++func enter_Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { ++ funcref := get_FaccessatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FACCESSAT_A<<4, "") == 0 { ++ *funcref = impl_Faccessat ++ } else { ++ *funcref = error_Faccessat ++ } ++ return (*funcref)(dirfd, path, mode, flags) ++} ++ ++func error_Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchdir(fd int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCHDIR<<4, uintptr(fd)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchmod(fd int, mode uint32) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCHMOD<<4, uintptr(fd), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { + var _p0 *byte +- _p0, err = BytePtrFromString(filesystem) ++ _p0, err = BytePtrFromString(path) + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___UMOUNT_A, uintptr(unsafe.Pointer(_p0)), uintptr(mtm), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FCHMODAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FchmodatAddr() *(func(dirfd int, path string, mode uint32, flags int) (err error)) ++ ++var Fchmodat = enter_Fchmodat ++ ++func enter_Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { ++ funcref := get_FchmodatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FCHMODAT_A<<4, "") == 0 { ++ *funcref = impl_Fchmodat ++ } else { ++ *funcref = error_Fchmodat ++ } ++ return (*funcref)(dirfd, path, mode, flags) ++} ++ ++func error_Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchown(fd int, uid int, gid int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCHOWN<<4, uintptr(fd), uintptr(uid), uintptr(gid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Chroot(path string) (err error) { ++func impl_Fchownat(fd int, path string, uid int, gid int, flags int) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___CHROOT_A, uintptr(unsafe.Pointer(_p0)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FCHOWNAT_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FchownatAddr() *(func(fd int, path string, uid int, gid int, flags int) (err error)) ++ ++var Fchownat = enter_Fchownat ++ ++func enter_Fchownat(fd int, path string, uid int, gid int, flags int) (err error) { ++ funcref := get_FchownatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FCHOWNAT_A<<4, "") == 0 { ++ *funcref = impl_Fchownat ++ } else { ++ *funcref = error_Fchownat + } ++ return (*funcref)(fd, path, uid, gid, flags) ++} ++ ++func error_Fchownat(fd int, path string, uid int, gid int, flags int) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Uname(buf *Utsname) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS___UNAME_A, uintptr(unsafe.Pointer(buf)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++func FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), uintptr(arg)) ++ runtime.ExitSyscall() ++ retval = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Gethostname(buf []byte) (err error) { ++func impl_Fdatasync(fd int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FDATASYNC<<4, uintptr(fd)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FdatasyncAddr() *(func(fd int) (err error)) ++ ++var Fdatasync = enter_Fdatasync ++ ++func enter_Fdatasync(fd int) (err error) { ++ funcref := get_FdatasyncAddr() ++ if funcptrtest(GetZosLibVec()+SYS_FDATASYNC<<4, "") == 0 { ++ *funcref = impl_Fdatasync ++ } else { ++ *funcref = error_Fdatasync ++ } ++ return (*funcref)(fd) ++} ++ ++func error_Fdatasync(fd int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fstat(fd int, stat *Stat_LE_t) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSTAT<<4, uintptr(fd), uintptr(unsafe.Pointer(stat))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FSTATAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_fstatatAddr() *(func(dirfd int, path string, stat *Stat_LE_t, flags int) (err error)) ++ ++var fstatat = enter_fstatat ++ ++func enter_fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) { ++ funcref := get_fstatatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FSTATAT_A<<4, "") == 0 { ++ *funcref = impl_fstatat ++ } else { ++ *funcref = error_fstatat ++ } ++ return (*funcref)(dirfd, path, stat, flags) ++} ++ ++func error_fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Lgetxattr(link string, attr string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(dest) > 0 { ++ _p2 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LGETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest))) ++ runtime.ExitSyscall() ++ sz = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_LgetxattrAddr() *(func(link string, attr string, dest []byte) (sz int, err error)) ++ ++var Lgetxattr = enter_Lgetxattr ++ ++func enter_Lgetxattr(link string, attr string, dest []byte) (sz int, err error) { ++ funcref := get_LgetxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LGETXATTR_A<<4, "") == 0 { ++ *funcref = impl_Lgetxattr ++ } else { ++ *funcref = error_Lgetxattr ++ } ++ return (*funcref)(link, attr, dest) ++} ++ ++func error_Lgetxattr(link string, attr string, dest []byte) (sz int, err error) { ++ sz = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Lsetxattr(path string, attr string, data []byte, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(data) > 0 { ++ _p2 = unsafe.Pointer(&data[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LSETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_LsetxattrAddr() *(func(path string, attr string, data []byte, flags int) (err error)) ++ ++var Lsetxattr = enter_Lsetxattr ++ ++func enter_Lsetxattr(path string, attr string, data []byte, flags int) (err error) { ++ funcref := get_LsetxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LSETXATTR_A<<4, "") == 0 { ++ *funcref = impl_Lsetxattr ++ } else { ++ *funcref = error_Lsetxattr ++ } ++ return (*funcref)(path, attr, data, flags) ++} ++ ++func error_Lsetxattr(path string, attr string, data []byte, flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Fstatfs(fd int, buf *Statfs_t) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSTATFS<<4, uintptr(fd), uintptr(unsafe.Pointer(buf))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FstatfsAddr() *(func(fd int, buf *Statfs_t) (err error)) ++ ++var Fstatfs = enter_Fstatfs ++ ++func enter_Fstatfs(fd int, buf *Statfs_t) (err error) { ++ funcref := get_FstatfsAddr() ++ if funcptrtest(GetZosLibVec()+SYS_FSTATFS<<4, "") == 0 { ++ *funcref = impl_Fstatfs ++ } else { ++ *funcref = error_Fstatfs ++ } ++ return (*funcref)(fd, buf) ++} ++ ++func error_Fstatfs(fd int, buf *Statfs_t) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstatvfs(fd int, stat *Statvfs_t) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSTATVFS<<4, uintptr(fd), uintptr(unsafe.Pointer(stat))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsync(fd int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSYNC<<4, uintptr(fd)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Futimes(fd int, tv []Timeval) (err error) { + var _p0 unsafe.Pointer +- if len(buf) > 0 { +- _p0 = unsafe.Pointer(&buf[0]) ++ if len(tv) > 0 { ++ _p0 = unsafe.Pointer(&tv[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } +- _, _, e1 := syscall_syscall(SYS___GETHOSTNAME_A, uintptr(_p0), uintptr(len(buf)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FUTIMES<<4, uintptr(fd), uintptr(_p0), uintptr(len(tv))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_FutimesAddr() *(func(fd int, tv []Timeval) (err error)) + +-func Getegid() (egid int) { +- r0, _, _ := syscall_rawsyscall(SYS_GETEGID, 0, 0, 0) +- egid = int(r0) ++var Futimes = enter_Futimes ++ ++func enter_Futimes(fd int, tv []Timeval) (err error) { ++ funcref := get_FutimesAddr() ++ if funcptrtest(GetZosLibVec()+SYS_FUTIMES<<4, "") == 0 { ++ *funcref = impl_Futimes ++ } else { ++ *funcref = error_Futimes ++ } ++ return (*funcref)(fd, tv) ++} ++ ++func error_Futimes(fd int, tv []Timeval) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Geteuid() (uid int) { +- r0, _, _ := syscall_rawsyscall(SYS_GETEUID, 0, 0, 0) +- uid = int(r0) ++func impl_Futimesat(dirfd int, path string, tv []Timeval) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(tv) > 0 { ++ _p1 = unsafe.Pointer(&tv[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FUTIMESAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(tv))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_FutimesatAddr() *(func(dirfd int, path string, tv []Timeval) (err error)) ++ ++var Futimesat = enter_Futimesat ++ ++func enter_Futimesat(dirfd int, path string, tv []Timeval) (err error) { ++ funcref := get_FutimesatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___FUTIMESAT_A<<4, "") == 0 { ++ *funcref = impl_Futimesat ++ } else { ++ *funcref = error_Futimesat ++ } ++ return (*funcref)(dirfd, path, tv) ++} ++ ++func error_Futimesat(dirfd int, path string, tv []Timeval) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getgid() (gid int) { +- r0, _, _ := syscall_rawsyscall(SYS_GETGID, 0, 0, 0) +- gid = int(r0) ++func Ftruncate(fd int, length int64) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FTRUNCATE<<4, uintptr(fd), uintptr(length)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getpid() (pid int) { +- r0, _, _ := syscall_rawsyscall(SYS_GETPID, 0, 0, 0) +- pid = int(r0) ++func impl_Getrandom(buf []byte, flags int) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETRANDOM<<4, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) ++ runtime.ExitSyscall() ++ n = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_GetrandomAddr() *(func(buf []byte, flags int) (n int, err error)) ++ ++var Getrandom = enter_Getrandom ++ ++func enter_Getrandom(buf []byte, flags int) (n int, err error) { ++ funcref := get_GetrandomAddr() ++ if funcptrtest(GetZosLibVec()+SYS_GETRANDOM<<4, "") == 0 { ++ *funcref = impl_Getrandom ++ } else { ++ *funcref = error_Getrandom ++ } ++ return (*funcref)(buf, flags) ++} ++ ++func error_Getrandom(buf []byte, flags int) (n int, err error) { ++ n = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getpgid(pid int) (pgid int, err error) { +- r0, _, e1 := syscall_rawsyscall(SYS_GETPGID, uintptr(pid), 0, 0) +- pgid = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_InotifyInit() (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec() + SYS_INOTIFY_INIT<<4) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_InotifyInitAddr() *(func() (fd int, err error)) ++ ++var InotifyInit = enter_InotifyInit ++ ++func enter_InotifyInit() (fd int, err error) { ++ funcref := get_InotifyInitAddr() ++ if funcptrtest(GetZosLibVec()+SYS_INOTIFY_INIT<<4, "") == 0 { ++ *funcref = impl_InotifyInit ++ } else { ++ *funcref = error_InotifyInit + } ++ return (*funcref)() ++} ++ ++func error_InotifyInit() (fd int, err error) { ++ fd = -1 ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getppid() (pid int) { +- r0, _, _ := syscall_rawsyscall(SYS_GETPPID, 0, 0, 0) +- pid = int(r0) ++func impl_InotifyInit1(flags int) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_INOTIFY_INIT1<<4, uintptr(flags)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_InotifyInit1Addr() *(func(flags int) (fd int, err error)) ++ ++var InotifyInit1 = enter_InotifyInit1 ++ ++func enter_InotifyInit1(flags int) (fd int, err error) { ++ funcref := get_InotifyInit1Addr() ++ if funcptrtest(GetZosLibVec()+SYS_INOTIFY_INIT1<<4, "") == 0 { ++ *funcref = impl_InotifyInit1 ++ } else { ++ *funcref = error_InotifyInit1 ++ } ++ return (*funcref)(flags) ++} ++ ++func error_InotifyInit1(flags int) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(pathname) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___INOTIFY_ADD_WATCH_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask)) ++ runtime.ExitSyscall() ++ watchdesc = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_InotifyAddWatchAddr() *(func(fd int, pathname string, mask uint32) (watchdesc int, err error)) ++ ++var InotifyAddWatch = enter_InotifyAddWatch ++ ++func enter_InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { ++ funcref := get_InotifyAddWatchAddr() ++ if funcptrtest(GetZosLibVec()+SYS___INOTIFY_ADD_WATCH_A<<4, "") == 0 { ++ *funcref = impl_InotifyAddWatch ++ } else { ++ *funcref = error_InotifyAddWatch ++ } ++ return (*funcref)(fd, pathname, mask) ++} ++ ++func error_InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { ++ watchdesc = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_INOTIFY_RM_WATCH<<4, uintptr(fd), uintptr(watchdesc)) ++ runtime.ExitSyscall() ++ success = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_InotifyRmWatchAddr() *(func(fd int, watchdesc uint32) (success int, err error)) ++ ++var InotifyRmWatch = enter_InotifyRmWatch ++ ++func enter_InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { ++ funcref := get_InotifyRmWatchAddr() ++ if funcptrtest(GetZosLibVec()+SYS_INOTIFY_RM_WATCH<<4, "") == 0 { ++ *funcref = impl_InotifyRmWatch ++ } else { ++ *funcref = error_InotifyRmWatch ++ } ++ return (*funcref)(fd, watchdesc) ++} ++ ++func error_InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { ++ success = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Listxattr(path string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LISTXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) ++ runtime.ExitSyscall() ++ sz = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_ListxattrAddr() *(func(path string, dest []byte) (sz int, err error)) ++ ++var Listxattr = enter_Listxattr ++ ++func enter_Listxattr(path string, dest []byte) (sz int, err error) { ++ funcref := get_ListxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LISTXATTR_A<<4, "") == 0 { ++ *funcref = impl_Listxattr ++ } else { ++ *funcref = error_Listxattr ++ } ++ return (*funcref)(path, dest) ++} ++ ++func error_Listxattr(path string, dest []byte) (sz int, err error) { ++ sz = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Llistxattr(path string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LLISTXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) ++ runtime.ExitSyscall() ++ sz = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_LlistxattrAddr() *(func(path string, dest []byte) (sz int, err error)) ++ ++var Llistxattr = enter_Llistxattr ++ ++func enter_Llistxattr(path string, dest []byte) (sz int, err error) { ++ funcref := get_LlistxattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LLISTXATTR_A<<4, "") == 0 { ++ *funcref = impl_Llistxattr ++ } else { ++ *funcref = error_Llistxattr ++ } ++ return (*funcref)(path, dest) ++} ++ ++func error_Llistxattr(path string, dest []byte) (sz int, err error) { ++ sz = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Lremovexattr(path string, attr string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LREMOVEXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_LremovexattrAddr() *(func(path string, attr string) (err error)) ++ ++var Lremovexattr = enter_Lremovexattr ++ ++func enter_Lremovexattr(path string, attr string) (err error) { ++ funcref := get_LremovexattrAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LREMOVEXATTR_A<<4, "") == 0 { ++ *funcref = impl_Lremovexattr ++ } else { ++ *funcref = error_Lremovexattr ++ } ++ return (*funcref)(path, attr) ++} ++ ++func error_Lremovexattr(path string, attr string) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Lutimes(path string, tv []Timeval) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(tv) > 0 { ++ _p1 = unsafe.Pointer(&tv[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LUTIMES_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(tv))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_LutimesAddr() *(func(path string, tv []Timeval) (err error)) ++ ++var Lutimes = enter_Lutimes ++ ++func enter_Lutimes(path string, tv []Timeval) (err error) { ++ funcref := get_LutimesAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LUTIMES_A<<4, "") == 0 { ++ *funcref = impl_Lutimes ++ } else { ++ *funcref = error_Lutimes ++ } ++ return (*funcref)(path, tv) ++} ++ ++func error_Lutimes(path string, tv []Timeval) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mprotect(b []byte, prot int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MPROTECT<<4, uintptr(_p0), uintptr(len(b)), uintptr(prot)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Msync(b []byte, flags int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MSYNC<<4, uintptr(_p0), uintptr(len(b)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Console2(cmsg *ConsMsg2, modstr *byte, concmd *uint32) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CONSOLE2<<4, uintptr(unsafe.Pointer(cmsg)), uintptr(unsafe.Pointer(modstr)), uintptr(unsafe.Pointer(concmd))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Poll(fds []PollFd, timeout int) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(fds) > 0 { ++ _p0 = unsafe.Pointer(&fds[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_POLL<<4, uintptr(_p0), uintptr(len(fds)), uintptr(timeout)) ++ runtime.ExitSyscall() ++ n = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READDIR_R_A<<4, uintptr(dirp), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Statfs(path string, buf *Statfs_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___STATFS_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_StatfsAddr() *(func(path string, buf *Statfs_t) (err error)) ++ ++var Statfs = enter_Statfs ++ ++func enter_Statfs(path string, buf *Statfs_t) (err error) { ++ funcref := get_StatfsAddr() ++ if funcptrtest(GetZosLibVec()+SYS___STATFS_A<<4, "") == 0 { ++ *funcref = impl_Statfs ++ } else { ++ *funcref = error_Statfs ++ } ++ return (*funcref)(path, buf) ++} ++ ++func error_Statfs(path string, buf *Statfs_t) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Syncfs(fd int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SYNCFS<<4, uintptr(fd)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_SyncfsAddr() *(func(fd int) (err error)) ++ ++var Syncfs = enter_Syncfs ++ ++func enter_Syncfs(fd int) (err error) { ++ funcref := get_SyncfsAddr() ++ if funcptrtest(GetZosLibVec()+SYS_SYNCFS<<4, "") == 0 { ++ *funcref = impl_Syncfs ++ } else { ++ *funcref = error_Syncfs ++ } ++ return (*funcref)(fd) ++} ++ ++func error_Syncfs(fd int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Times(tms *Tms) (ticks uintptr, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TIMES<<4, uintptr(unsafe.Pointer(tms))) ++ runtime.ExitSyscall() ++ ticks = uintptr(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func W_Getmntent(buff *byte, size int) (lastsys int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_W_GETMNTENT<<4, uintptr(unsafe.Pointer(buff)), uintptr(size)) ++ runtime.ExitSyscall() ++ lastsys = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func W_Getmntent_A(buff *byte, size int) (lastsys int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___W_GETMNTENT_A<<4, uintptr(unsafe.Pointer(buff)), uintptr(size)) ++ runtime.ExitSyscall() ++ lastsys = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(filesystem) ++ if err != nil { ++ return ++ } ++ var _p2 *byte ++ _p2, err = BytePtrFromString(fstype) ++ if err != nil { ++ return ++ } ++ var _p3 *byte ++ _p3, err = BytePtrFromString(parm) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MOUNT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(mtm), uintptr(parmlen), uintptr(unsafe.Pointer(_p3))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func unmount_LE(filesystem string, mtm int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(filesystem) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UMOUNT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mtm)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chroot(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHROOT_A<<4, uintptr(unsafe.Pointer(_p0))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SELECT<<4, uintptr(nmsgsfds), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout))) ++ runtime.ExitSyscall() ++ ret = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Uname(buf *Utsname) (err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_____OSNAME_A<<4, uintptr(unsafe.Pointer(buf))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Unshare(flags int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_UNSHARE<<4, uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_UnshareAddr() *(func(flags int) (err error)) ++ ++var Unshare = enter_Unshare ++ ++func enter_Unshare(flags int) (err error) { ++ funcref := get_UnshareAddr() ++ if funcptrtest(GetZosLibVec()+SYS_UNSHARE<<4, "") == 0 { ++ *funcref = impl_Unshare ++ } else { ++ *funcref = error_Unshare ++ } ++ return (*funcref)(flags) ++} ++ ++func error_Unshare(flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Gethostname(buf []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETHOSTNAME_A<<4, uintptr(_p0), uintptr(len(buf))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getgid() (gid int) { ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETGID<<4) ++ gid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpid() (pid int) { ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETPID<<4) ++ pid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpgid(pid int) (pgid int, err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETPGID<<4, uintptr(pid)) ++ pgid = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getppid() (pid int) { ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETPPID<<4) ++ pid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpriority(which int, who int) (prio int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETPRIORITY<<4, uintptr(which), uintptr(who)) ++ runtime.ExitSyscall() ++ prio = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrlimit(resource int, rlim *Rlimit) (err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETRLIMIT<<4, uintptr(resource), uintptr(unsafe.Pointer(rlim))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getrusage(who int, rusage *rusage_zos) (err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETRUSAGE<<4, uintptr(who), uintptr(unsafe.Pointer(rusage))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getegid() (egid int) { ++ runtime.EnterSyscall() ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETEGID<<4) ++ runtime.ExitSyscall() ++ egid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Geteuid() (euid int) { ++ runtime.EnterSyscall() ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETEUID<<4) ++ runtime.ExitSyscall() ++ euid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getsid(pid int) (sid int, err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETSID<<4, uintptr(pid)) ++ sid = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getuid() (uid int) { ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETUID<<4) ++ uid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Kill(pid int, sig Signal) (err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_KILL<<4, uintptr(pid), uintptr(sig)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lchown(path string, uid int, gid int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LCHOWN_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Link(path string, link string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LINK_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldPath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newPath) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LINKAT_A<<4, uintptr(oldDirFd), uintptr(unsafe.Pointer(_p0)), uintptr(newDirFd), uintptr(unsafe.Pointer(_p1)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_LinkatAddr() *(func(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error)) ++ ++var Linkat = enter_Linkat ++ ++func enter_Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) { ++ funcref := get_LinkatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___LINKAT_A<<4, "") == 0 { ++ *funcref = impl_Linkat ++ } else { ++ *funcref = error_Linkat ++ } ++ return (*funcref)(oldDirFd, oldPath, newDirFd, newPath, flags) ++} ++ ++func error_Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Listen(s int, n int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_LISTEN<<4, uintptr(s), uintptr(n)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func lstat(path string, stat *Stat_LE_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LSTAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkdir(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKDIR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Mkdirat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKDIRAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_MkdiratAddr() *(func(dirfd int, path string, mode uint32) (err error)) ++ ++var Mkdirat = enter_Mkdirat ++ ++func enter_Mkdirat(dirfd int, path string, mode uint32) (err error) { ++ funcref := get_MkdiratAddr() ++ if funcptrtest(GetZosLibVec()+SYS___MKDIRAT_A<<4, "") == 0 { ++ *funcref = impl_Mkdirat ++ } else { ++ *funcref = error_Mkdirat ++ } ++ return (*funcref)(dirfd, path, mode) ++} ++ ++func error_Mkdirat(dirfd int, path string, mode uint32) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkfifo(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKFIFO_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mknod(path string, mode uint32, dev int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKNOD_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKNODAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_MknodatAddr() *(func(dirfd int, path string, mode uint32, dev int) (err error)) ++ ++var Mknodat = enter_Mknodat ++ ++func enter_Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { ++ funcref := get_MknodatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___MKNODAT_A<<4, "") == 0 { ++ *funcref = impl_Mknodat ++ } else { ++ *funcref = error_Mknodat ++ } ++ return (*funcref)(dirfd, path, mode, dev) ++} ++ ++func error_Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_PivotRoot(newroot string, oldroot string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(newroot) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(oldroot) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___PIVOT_ROOT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_PivotRootAddr() *(func(newroot string, oldroot string) (err error)) ++ ++var PivotRoot = enter_PivotRoot ++ ++func enter_PivotRoot(newroot string, oldroot string) (err error) { ++ funcref := get_PivotRootAddr() ++ if funcptrtest(GetZosLibVec()+SYS___PIVOT_ROOT_A<<4, "") == 0 { ++ *funcref = impl_PivotRoot ++ } else { ++ *funcref = error_PivotRoot ++ } ++ return (*funcref)(newroot, oldroot) ++} ++ ++func error_PivotRoot(newroot string, oldroot string) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Pread(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PREAD<<4, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset)) ++ runtime.ExitSyscall() ++ n = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getpriority(which int, who int) (prio int, err error) { +- r0, _, e1 := syscall_syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0) +- prio = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++func Pwrite(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PWRITE<<4, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset)) ++ runtime.ExitSyscall() ++ n = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getrlimit(resource int, rlim *Rlimit) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___PRCTL_A<<4, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_PrctlAddr() *(func(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)) + +-func getrusage(who int, rusage *rusage_zos) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var Prctl = enter_Prctl ++ ++func enter_Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { ++ funcref := get_PrctlAddr() ++ if funcptrtest(GetZosLibVec()+SYS___PRCTL_A<<4, "") == 0 { ++ *funcref = impl_Prctl ++ } else { ++ *funcref = error_Prctl + } +- return ++ return (*funcref)(option, arg2, arg3, arg4, arg5) + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- +-func Getsid(pid int) (sid int, err error) { +- r0, _, e1 := syscall_rawsyscall(SYS_GETSID, uintptr(pid), 0, 0) +- sid = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } ++func error_Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getuid() (uid int) { +- r0, _, _ := syscall_rawsyscall(SYS_GETUID, 0, 0, 0) +- uid = int(r0) ++func impl_Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PRLIMIT<<4, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_PrlimitAddr() *(func(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error)) + +-func Kill(pid int, sig Signal) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var Prlimit = enter_Prlimit ++ ++func enter_Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { ++ funcref := get_PrlimitAddr() ++ if funcptrtest(GetZosLibVec()+SYS_PRLIMIT<<4, "") == 0 { ++ *funcref = impl_Prlimit ++ } else { ++ *funcref = error_Prlimit + } ++ return (*funcref)(pid, resource, newlimit, old) ++} ++ ++func error_Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Lchown(path string, uid int, gid int) (err error) { ++func Rename(from string, to string) (err error) { + var _p0 *byte +- _p0, err = BytePtrFromString(path) ++ _p0, err = BytePtrFromString(from) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(to) + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___LCHOWN_A, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RENAME_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Link(path string, link string) (err error) { ++func impl_Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { + var _p0 *byte +- _p0, err = BytePtrFromString(path) ++ _p0, err = BytePtrFromString(oldpath) + if err != nil { + return + } + var _p1 *byte +- _p1, err = BytePtrFromString(link) ++ _p1, err = BytePtrFromString(newpath) + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___LINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RENAMEAT_A<<4, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_RenameatAddr() *(func(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)) + +-func Listen(s int, n int) (err error) { +- _, _, e1 := syscall_syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var Renameat = enter_Renameat ++ ++func enter_Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { ++ funcref := get_RenameatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___RENAMEAT_A<<4, "") == 0 { ++ *funcref = impl_Renameat ++ } else { ++ *funcref = error_Renameat + } ++ return (*funcref)(olddirfd, oldpath, newdirfd, newpath) ++} ++ ++func error_Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func lstat(path string, stat *Stat_LE_t) (err error) { ++func impl_Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { + var _p0 *byte +- _p0, err = BytePtrFromString(path) ++ _p0, err = BytePtrFromString(oldpath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newpath) + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___LSTAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RENAMEAT2_A<<4, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_Renameat2Addr() *(func(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error)) + +-func Mkdir(path string, mode uint32) (err error) { +- var _p0 *byte +- _p0, err = BytePtrFromString(path) +- if err != nil { +- return +- } +- _, _, e1 := syscall_syscall(SYS___MKDIR_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++var Renameat2 = enter_Renameat2 ++ ++func enter_Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { ++ funcref := get_Renameat2Addr() ++ if funcptrtest(GetZosLibVec()+SYS___RENAMEAT2_A<<4, "") == 0 { ++ *funcref = impl_Renameat2 ++ } else { ++ *funcref = error_Renameat2 + } ++ return (*funcref)(olddirfd, oldpath, newdirfd, newpath, flags) ++} ++ ++func error_Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Mkfifo(path string, mode uint32) (err error) { ++func Rmdir(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___MKFIFO_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RMDIR_A<<4, uintptr(unsafe.Pointer(_p0))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Mknod(path string, mode uint32, dev int) (err error) { +- var _p0 *byte +- _p0, err = BytePtrFromString(path) +- if err != nil { +- return +- } +- _, _, e1 := syscall_syscall(SYS___MKNOD_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) +- if e1 != 0 { +- err = errnoErr(e1) ++func Seek(fd int, offset int64, whence int) (off int64, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_LSEEK<<4, uintptr(fd), uintptr(offset), uintptr(whence)) ++ runtime.ExitSyscall() ++ off = int64(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Pread(fd int, p []byte, offset int64) (n int, err error) { +- var _p0 unsafe.Pointer +- if len(p) > 0 { +- _p0 = unsafe.Pointer(&p[0]) +- } else { +- _p0 = unsafe.Pointer(&_zero) ++func Setegid(egid int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETEGID<<4, uintptr(egid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } +- r0, _, e1 := syscall_syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Seteuid(euid int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETEUID<<4, uintptr(euid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Pwrite(fd int, p []byte, offset int64) (n int, err error) { ++func impl_Sethostname(p []byte) (err error) { + var _p0 unsafe.Pointer + if len(p) > 0 { + _p0 = unsafe.Pointer(&p[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } +- r0, _, e1 := syscall_syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SETHOSTNAME_A<<4, uintptr(_p0), uintptr(len(p))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_SethostnameAddr() *(func(p []byte) (err error)) + +-func Readlink(path string, buf []byte) (n int, err error) { +- var _p0 *byte +- _p0, err = BytePtrFromString(path) +- if err != nil { +- return +- } +- var _p1 unsafe.Pointer +- if len(buf) > 0 { +- _p1 = unsafe.Pointer(&buf[0]) ++var Sethostname = enter_Sethostname ++ ++func enter_Sethostname(p []byte) (err error) { ++ funcref := get_SethostnameAddr() ++ if funcptrtest(GetZosLibVec()+SYS___SETHOSTNAME_A<<4, "") == 0 { ++ *funcref = impl_Sethostname + } else { +- _p1 = unsafe.Pointer(&_zero) ++ *funcref = error_Sethostname + } +- r0, _, e1 := syscall_syscall(SYS___READLINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } +- return ++ return (*funcref)(p) + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- +-func Rename(from string, to string) (err error) { +- var _p0 *byte +- _p0, err = BytePtrFromString(from) +- if err != nil { +- return +- } +- var _p1 *byte +- _p1, err = BytePtrFromString(to) +- if err != nil { +- return +- } +- _, _, e1 := syscall_syscall(SYS___RENAME_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) +- if e1 != 0 { +- err = errnoErr(e1) +- } ++func error_Sethostname(p []byte) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Rmdir(path string) (err error) { +- var _p0 *byte +- _p0, err = BytePtrFromString(path) +- if err != nil { +- return +- } +- _, _, e1 := syscall_syscall(SYS___RMDIR_A, uintptr(unsafe.Pointer(_p0)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_Setns(fd int, nstype int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETNS<<4, uintptr(fd), uintptr(nstype)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++//go:nosplit ++func get_SetnsAddr() *(func(fd int, nstype int) (err error)) + +-func Seek(fd int, offset int64, whence int) (off int64, err error) { +- r0, _, e1 := syscall_syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence)) +- off = int64(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++var Setns = enter_Setns ++ ++func enter_Setns(fd int, nstype int) (err error) { ++ funcref := get_SetnsAddr() ++ if funcptrtest(GetZosLibVec()+SYS_SETNS<<4, "") == 0 { ++ *funcref = impl_Setns ++ } else { ++ *funcref = error_Setns + } ++ return (*funcref)(fd, nstype) ++} ++ ++func error_Setns(fd int, nstype int) (err error) { ++ err = ENOSYS + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setpriority(which int, who int, prio int) (err error) { +- _, _, e1 := syscall_syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio)) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETPRIORITY<<4, uintptr(which), uintptr(who), uintptr(prio)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -971,9 +2910,9 @@ func Setpriority(which int, who int, prio int) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setpgid(pid int, pgid int) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETPGID<<4, uintptr(pid), uintptr(pgid)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -981,9 +2920,9 @@ func Setpgid(pid int, pgid int) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setrlimit(resource int, lim *Rlimit) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(lim)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETRLIMIT<<4, uintptr(resource), uintptr(unsafe.Pointer(lim))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -991,9 +2930,9 @@ func Setrlimit(resource int, lim *Rlimit) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setregid(rgid int, egid int) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETREGID<<4, uintptr(rgid), uintptr(egid)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1001,9 +2940,9 @@ func Setregid(rgid int, egid int) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setreuid(ruid int, euid int) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETREUID<<4, uintptr(ruid), uintptr(euid)) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1011,10 +2950,10 @@ func Setreuid(ruid int, euid int) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setsid() (pid int, err error) { +- r0, _, e1 := syscall_rawsyscall(SYS_SETSID, 0, 0, 0) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec() + SYS_SETSID<<4) + pid = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1022,9 +2961,11 @@ func Setsid() (pid int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setuid(uid int) (err error) { +- _, _, e1 := syscall_syscall(SYS_SETUID, uintptr(uid), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETUID<<4, uintptr(uid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1032,9 +2973,11 @@ func Setuid(uid int) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Setgid(uid int) (err error) { +- _, _, e1 := syscall_syscall(SYS_SETGID, uintptr(uid), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETGID<<4, uintptr(uid)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1042,9 +2985,11 @@ func Setgid(uid int) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Shutdown(fd int, how int) (err error) { +- _, _, e1 := syscall_syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHUTDOWN<<4, uintptr(fd), uintptr(how)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1057,9 +3002,11 @@ func stat(path string, statLE *Stat_LE_t) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___STAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(statLE)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___STAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(statLE))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1077,17 +3024,63 @@ func Symlink(path string, link string) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___SYMLINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SYMLINK_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Symlinkat(oldPath string, dirfd int, newPath string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldPath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newPath) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SYMLINKAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(dirfd), uintptr(unsafe.Pointer(_p1))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + ++//go:nosplit ++func get_SymlinkatAddr() *(func(oldPath string, dirfd int, newPath string) (err error)) ++ ++var Symlinkat = enter_Symlinkat ++ ++func enter_Symlinkat(oldPath string, dirfd int, newPath string) (err error) { ++ funcref := get_SymlinkatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___SYMLINKAT_A<<4, "") == 0 { ++ *funcref = impl_Symlinkat ++ } else { ++ *funcref = error_Symlinkat ++ } ++ return (*funcref)(oldPath, dirfd, newPath) ++} ++ ++func error_Symlinkat(oldPath string, dirfd int, newPath string) (err error) { ++ err = ENOSYS ++ return ++} ++ + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Sync() { +- syscall_syscall(SYS_SYNC, 0, 0, 0) ++ runtime.EnterSyscall() ++ CallLeFuncWithErr(GetZosLibVec() + SYS_SYNC<<4) ++ runtime.ExitSyscall() + return + } + +@@ -1099,9 +3092,11 @@ func Truncate(path string, length int64) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___TRUNCATE_A, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___TRUNCATE_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(length)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1109,9 +3104,11 @@ func Truncate(path string, length int64) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Tcgetattr(fildes int, termptr *Termios) (err error) { +- _, _, e1 := syscall_syscall(SYS_TCGETATTR, uintptr(fildes), uintptr(unsafe.Pointer(termptr)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TCGETATTR<<4, uintptr(fildes), uintptr(unsafe.Pointer(termptr))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1119,9 +3116,11 @@ func Tcgetattr(fildes int, termptr *Termios) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Tcsetattr(fildes int, when int, termptr *Termios) (err error) { +- _, _, e1 := syscall_syscall(SYS_TCSETATTR, uintptr(fildes), uintptr(when), uintptr(unsafe.Pointer(termptr))) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TCSETATTR<<4, uintptr(fildes), uintptr(when), uintptr(unsafe.Pointer(termptr))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1129,7 +3128,9 @@ func Tcsetattr(fildes int, when int, termptr *Termios) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func Umask(mask int) (oldmask int) { +- r0, _, _ := syscall_syscall(SYS_UMASK, uintptr(mask), 0, 0) ++ runtime.EnterSyscall() ++ r0, _, _ := CallLeFuncWithErr(GetZosLibVec()+SYS_UMASK<<4, uintptr(mask)) ++ runtime.ExitSyscall() + oldmask = int(r0) + return + } +@@ -1142,10 +3143,49 @@ func Unlink(path string) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___UNLINK_A, uintptr(unsafe.Pointer(_p0)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UNLINK_A<<4, uintptr(unsafe.Pointer(_p0))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_Unlinkat(dirfd int, path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UNLINKAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_UnlinkatAddr() *(func(dirfd int, path string, flags int) (err error)) ++ ++var Unlinkat = enter_Unlinkat ++ ++func enter_Unlinkat(dirfd int, path string, flags int) (err error) { ++ funcref := get_UnlinkatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___UNLINKAT_A<<4, "") == 0 { ++ *funcref = impl_Unlinkat ++ } else { ++ *funcref = error_Unlinkat + } ++ return (*funcref)(dirfd, path, flags) ++} ++ ++func error_Unlinkat(dirfd int, path string, flags int) (err error) { ++ err = ENOSYS + return + } + +@@ -1157,9 +3197,11 @@ func Utime(path string, utim *Utimbuf) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___UTIME_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(utim)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UTIME_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(utim))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1172,11 +3214,91 @@ func open(path string, mode int, perm uint32) (fd int, err error) { + if err != nil { + return + } +- r0, _, e1 := syscall_syscall(SYS___OPEN_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___OPEN_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___OPENAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_openatAddr() *(func(dirfd int, path string, flags int, mode uint32) (fd int, err error)) ++ ++var openat = enter_openat ++ ++func enter_openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { ++ funcref := get_openatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___OPENAT_A<<4, "") == 0 { ++ *funcref = impl_openat ++ } else { ++ *funcref = error_openat ++ } ++ return (*funcref)(dirfd, path, flags, mode) ++} ++ ++func error_openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func impl_openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___OPENAT2_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(open_how)), uintptr(size)) ++ runtime.ExitSyscall() + fd = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_openat2Addr() *(func(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error)) ++ ++var openat2 = enter_openat2 ++ ++func enter_openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { ++ funcref := get_openat2Addr() ++ if funcptrtest(GetZosLibVec()+SYS___OPENAT2_A<<4, "") == 0 { ++ *funcref = impl_openat2 ++ } else { ++ *funcref = error_openat2 + } ++ return (*funcref)(dirfd, path, open_how, size) ++} ++ ++func error_openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { ++ fd = -1 ++ err = ENOSYS + return + } + +@@ -1188,9 +3310,23 @@ func remove(path string) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_REMOVE<<4, uintptr(unsafe.Pointer(_p0))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func waitid(idType int, id int, info *Siginfo, options int) (err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAITID<<4, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1198,10 +3334,12 @@ func remove(path string) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) { +- r0, _, e1 := syscall_syscall(SYS_WAITPID, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options)) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAITPID<<4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options)) ++ runtime.ExitSyscall() + wpid = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1209,9 +3347,9 @@ func waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func gettimeofday(tv *timeval_zos) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETTIMEOFDAY<<4, uintptr(unsafe.Pointer(tv))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1219,9 +3357,9 @@ func gettimeofday(tv *timeval_zos) (err error) { + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + + func pipe(p *[2]_C_int) (err error) { +- _, _, e1 := syscall_rawsyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PIPE<<4, uintptr(unsafe.Pointer(p))) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +@@ -1234,20 +3372,87 @@ func utimes(path string, timeval *[2]Timeval) (err error) { + if err != nil { + return + } +- _, _, e1 := syscall_syscall(SYS___UTIMES_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0) +- if e1 != 0 { +- err = errnoErr(e1) ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UTIMES_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval))) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) { +- r0, _, e1 := syscall_syscall6(SYS_SELECT, uintptr(nmsgsfds), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0) +- ret = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) ++func impl_utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UTIMENSAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(ts)), uintptr(flags)) ++ runtime.ExitSyscall() ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++//go:nosplit ++func get_utimensatAddr() *(func(dirfd int, path string, ts *[2]Timespec, flags int) (err error)) ++ ++var utimensat = enter_utimensat ++ ++func enter_utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) { ++ funcref := get_utimensatAddr() ++ if funcptrtest(GetZosLibVec()+SYS___UTIMENSAT_A<<4, "") == 0 { ++ *funcref = impl_utimensat ++ } else { ++ *funcref = error_utimensat ++ } ++ return (*funcref)(dirfd, path, ts, flags) ++} ++ ++func error_utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) { ++ err = ENOSYS ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Posix_openpt(oflag int) (fd int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_POSIX_OPENPT<<4, uintptr(oflag)) ++ runtime.ExitSyscall() ++ fd = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Grantpt(fildes int) (rc int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GRANTPT<<4, uintptr(fildes)) ++ runtime.ExitSyscall() ++ rc = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unlockpt(fildes int) (rc int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_UNLOCKPT<<4, uintptr(fildes)) ++ runtime.ExitSyscall() ++ rc = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) + } + return + } +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go +index 0cc3ce496e22..53aef5dc58df 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go +@@ -452,4 +452,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +index 856d92d69ef9..71d524763d34 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +@@ -374,4 +374,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go +index 8d467094cf57..c747706131cb 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go +@@ -416,4 +416,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +index edc173244d0d..f96e214f6d40 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +@@ -319,4 +319,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +index 445eba206155..28425346cf18 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +@@ -313,4 +313,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go +index adba01bca701..d0953018dae0 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go +@@ -436,4 +436,9 @@ const ( + SYS_FUTEX_WAKE = 4454 + SYS_FUTEX_WAIT = 4455 + SYS_FUTEX_REQUEUE = 4456 ++ SYS_STATMOUNT = 4457 ++ SYS_LISTMOUNT = 4458 ++ SYS_LSM_GET_SELF_ATTR = 4459 ++ SYS_LSM_SET_SELF_ATTR = 4460 ++ SYS_LSM_LIST_MODULES = 4461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go +index 014c4e9c7a75..295c7f4b8184 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go +@@ -366,4 +366,9 @@ const ( + SYS_FUTEX_WAKE = 5454 + SYS_FUTEX_WAIT = 5455 + SYS_FUTEX_REQUEUE = 5456 ++ SYS_STATMOUNT = 5457 ++ SYS_LISTMOUNT = 5458 ++ SYS_LSM_GET_SELF_ATTR = 5459 ++ SYS_LSM_SET_SELF_ATTR = 5460 ++ SYS_LSM_LIST_MODULES = 5461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go +index ccc97d74d05d..d1a9eaca7a41 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go +@@ -366,4 +366,9 @@ const ( + SYS_FUTEX_WAKE = 5454 + SYS_FUTEX_WAIT = 5455 + SYS_FUTEX_REQUEUE = 5456 ++ SYS_STATMOUNT = 5457 ++ SYS_LISTMOUNT = 5458 ++ SYS_LSM_GET_SELF_ATTR = 5459 ++ SYS_LSM_SET_SELF_ATTR = 5460 ++ SYS_LSM_LIST_MODULES = 5461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go +index ec2b64a95d74..bec157c39fd0 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go +@@ -436,4 +436,9 @@ const ( + SYS_FUTEX_WAKE = 4454 + SYS_FUTEX_WAIT = 4455 + SYS_FUTEX_REQUEUE = 4456 ++ SYS_STATMOUNT = 4457 ++ SYS_LISTMOUNT = 4458 ++ SYS_LSM_GET_SELF_ATTR = 4459 ++ SYS_LSM_SET_SELF_ATTR = 4460 ++ SYS_LSM_LIST_MODULES = 4461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go +index 21a839e338b3..7ee7bdc435cf 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go +@@ -443,4 +443,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go +index c11121ec3b4d..fad1f25b449d 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go +@@ -415,4 +415,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go +index 909b631fcb45..7d3e16357d61 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go +@@ -415,4 +415,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +index e49bed16ea6b..0ed53ad9f7e9 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +@@ -320,4 +320,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go +index 66017d2d32b3..2fba04ad5006 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go +@@ -381,4 +381,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go +index 47bab18dcedb..621d00d741bf 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go +@@ -394,4 +394,9 @@ const ( + SYS_FUTEX_WAKE = 454 + SYS_FUTEX_WAIT = 455 + SYS_FUTEX_REQUEUE = 456 ++ SYS_STATMOUNT = 457 ++ SYS_LISTMOUNT = 458 ++ SYS_LSM_GET_SELF_ATTR = 459 ++ SYS_LSM_SET_SELF_ATTR = 460 ++ SYS_LSM_LIST_MODULES = 461 + ) +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go +index b2e308581990..5e8c263ca9c6 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go +@@ -1,2669 +1,2852 @@ +-// Copyright 2020 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 run mksyscall_zos_s390x.go -o_sysnum zsysnum_zos_s390x.go -o_syscall zsyscall_zos_s390x.go -i_syscall syscall_zos_s390x.go -o_asm zsymaddr_zos_s390x.s ++// Code generated by the command above; see README.md. DO NOT EDIT. + + //go:build zos && s390x + + package unix + +-// TODO: auto-generate. +- + const ( +- SYS_ACOSD128 = 0xB80 +- SYS_ACOSD32 = 0xB7E +- SYS_ACOSD64 = 0xB7F +- SYS_ACOSHD128 = 0xB83 +- SYS_ACOSHD32 = 0xB81 +- SYS_ACOSHD64 = 0xB82 +- SYS_AIO_FSYNC = 0xC69 +- SYS_ASCTIME = 0x0AE +- SYS_ASCTIME64 = 0xCD7 +- SYS_ASCTIME64_R = 0xCD8 +- SYS_ASIND128 = 0xB86 +- SYS_ASIND32 = 0xB84 +- SYS_ASIND64 = 0xB85 +- SYS_ASINHD128 = 0xB89 +- SYS_ASINHD32 = 0xB87 +- SYS_ASINHD64 = 0xB88 +- SYS_ATAN2D128 = 0xB8F +- SYS_ATAN2D32 = 0xB8D +- SYS_ATAN2D64 = 0xB8E +- SYS_ATAND128 = 0xB8C +- SYS_ATAND32 = 0xB8A +- SYS_ATAND64 = 0xB8B +- SYS_ATANHD128 = 0xB92 +- SYS_ATANHD32 = 0xB90 +- SYS_ATANHD64 = 0xB91 +- SYS_BIND2ADDRSEL = 0xD59 +- SYS_C16RTOMB = 0xD40 +- SYS_C32RTOMB = 0xD41 +- SYS_CBRTD128 = 0xB95 +- SYS_CBRTD32 = 0xB93 +- SYS_CBRTD64 = 0xB94 +- SYS_CEILD128 = 0xB98 +- SYS_CEILD32 = 0xB96 +- SYS_CEILD64 = 0xB97 +- SYS_CLEARENV = 0x0C9 +- SYS_CLEARERR_UNLOCKED = 0xCA1 +- SYS_CLOCK = 0x0AA +- SYS_CLOGL = 0xA00 +- SYS_CLRMEMF = 0x0BD +- SYS_CONJ = 0xA03 +- SYS_CONJF = 0xA06 +- SYS_CONJL = 0xA09 +- SYS_COPYSIGND128 = 0xB9E +- SYS_COPYSIGND32 = 0xB9C +- SYS_COPYSIGND64 = 0xB9D +- SYS_COSD128 = 0xBA1 +- SYS_COSD32 = 0xB9F +- SYS_COSD64 = 0xBA0 +- SYS_COSHD128 = 0xBA4 +- SYS_COSHD32 = 0xBA2 +- SYS_COSHD64 = 0xBA3 +- SYS_CPOW = 0xA0C +- SYS_CPOWF = 0xA0F +- SYS_CPOWL = 0xA12 +- SYS_CPROJ = 0xA15 +- SYS_CPROJF = 0xA18 +- SYS_CPROJL = 0xA1B +- SYS_CREAL = 0xA1E +- SYS_CREALF = 0xA21 +- SYS_CREALL = 0xA24 +- SYS_CSIN = 0xA27 +- SYS_CSINF = 0xA2A +- SYS_CSINH = 0xA30 +- SYS_CSINHF = 0xA33 +- SYS_CSINHL = 0xA36 +- SYS_CSINL = 0xA2D +- SYS_CSNAP = 0x0C5 +- SYS_CSQRT = 0xA39 +- SYS_CSQRTF = 0xA3C +- SYS_CSQRTL = 0xA3F +- SYS_CTAN = 0xA42 +- SYS_CTANF = 0xA45 +- SYS_CTANH = 0xA4B +- SYS_CTANHF = 0xA4E +- SYS_CTANHL = 0xA51 +- SYS_CTANL = 0xA48 +- SYS_CTIME = 0x0AB +- SYS_CTIME64 = 0xCD9 +- SYS_CTIME64_R = 0xCDA +- SYS_CTRACE = 0x0C6 +- SYS_DIFFTIME = 0x0A7 +- SYS_DIFFTIME64 = 0xCDB +- SYS_DLADDR = 0xC82 +- SYS_DYNALLOC = 0x0C3 +- SYS_DYNFREE = 0x0C2 +- SYS_ERFCD128 = 0xBAA +- SYS_ERFCD32 = 0xBA8 +- SYS_ERFCD64 = 0xBA9 +- SYS_ERFD128 = 0xBA7 +- SYS_ERFD32 = 0xBA5 +- SYS_ERFD64 = 0xBA6 +- SYS_EXP2D128 = 0xBB0 +- SYS_EXP2D32 = 0xBAE +- SYS_EXP2D64 = 0xBAF +- SYS_EXPD128 = 0xBAD +- SYS_EXPD32 = 0xBAB +- SYS_EXPD64 = 0xBAC +- SYS_EXPM1D128 = 0xBB3 +- SYS_EXPM1D32 = 0xBB1 +- SYS_EXPM1D64 = 0xBB2 +- SYS_FABSD128 = 0xBB6 +- SYS_FABSD32 = 0xBB4 +- SYS_FABSD64 = 0xBB5 +- SYS_FDELREC_UNLOCKED = 0xCA2 +- SYS_FDIMD128 = 0xBB9 +- SYS_FDIMD32 = 0xBB7 +- SYS_FDIMD64 = 0xBB8 +- SYS_FDOPEN_UNLOCKED = 0xCFC +- SYS_FECLEAREXCEPT = 0xAEA +- SYS_FEGETENV = 0xAEB +- SYS_FEGETEXCEPTFLAG = 0xAEC +- SYS_FEGETROUND = 0xAED +- SYS_FEHOLDEXCEPT = 0xAEE +- SYS_FEOF_UNLOCKED = 0xCA3 +- SYS_FERAISEEXCEPT = 0xAEF +- SYS_FERROR_UNLOCKED = 0xCA4 +- SYS_FESETENV = 0xAF0 +- SYS_FESETEXCEPTFLAG = 0xAF1 +- SYS_FESETROUND = 0xAF2 +- SYS_FETCHEP = 0x0BF +- SYS_FETESTEXCEPT = 0xAF3 +- SYS_FEUPDATEENV = 0xAF4 +- SYS_FE_DEC_GETROUND = 0xBBA +- SYS_FE_DEC_SETROUND = 0xBBB +- SYS_FFLUSH_UNLOCKED = 0xCA5 +- SYS_FGETC_UNLOCKED = 0xC80 +- SYS_FGETPOS64 = 0xCEE +- SYS_FGETPOS64_UNLOCKED = 0xCF4 +- SYS_FGETPOS_UNLOCKED = 0xCA6 +- SYS_FGETS_UNLOCKED = 0xC7C +- SYS_FGETWC_UNLOCKED = 0xCA7 +- SYS_FGETWS_UNLOCKED = 0xCA8 +- SYS_FILENO_UNLOCKED = 0xCA9 +- SYS_FLDATA = 0x0C1 +- SYS_FLDATA_UNLOCKED = 0xCAA +- SYS_FLOCATE_UNLOCKED = 0xCAB +- SYS_FLOORD128 = 0xBBE +- SYS_FLOORD32 = 0xBBC +- SYS_FLOORD64 = 0xBBD +- SYS_FMA = 0xA63 +- SYS_FMAD128 = 0xBC1 +- SYS_FMAD32 = 0xBBF +- SYS_FMAD64 = 0xBC0 +- SYS_FMAF = 0xA66 +- SYS_FMAL = 0xA69 +- SYS_FMAX = 0xA6C +- SYS_FMAXD128 = 0xBC4 +- SYS_FMAXD32 = 0xBC2 +- SYS_FMAXD64 = 0xBC3 +- SYS_FMAXF = 0xA6F +- SYS_FMAXL = 0xA72 +- SYS_FMIN = 0xA75 +- SYS_FMIND128 = 0xBC7 +- SYS_FMIND32 = 0xBC5 +- SYS_FMIND64 = 0xBC6 +- SYS_FMINF = 0xA78 +- SYS_FMINL = 0xA7B +- SYS_FMODD128 = 0xBCA +- SYS_FMODD32 = 0xBC8 +- SYS_FMODD64 = 0xBC9 +- SYS_FOPEN64 = 0xD49 +- SYS_FOPEN64_UNLOCKED = 0xD4A +- SYS_FOPEN_UNLOCKED = 0xCFA +- SYS_FPRINTF_UNLOCKED = 0xCAC +- SYS_FPUTC_UNLOCKED = 0xC81 +- SYS_FPUTS_UNLOCKED = 0xC7E +- SYS_FPUTWC_UNLOCKED = 0xCAD +- SYS_FPUTWS_UNLOCKED = 0xCAE +- SYS_FREAD_NOUPDATE = 0xCEC +- SYS_FREAD_NOUPDATE_UNLOCKED = 0xCED +- SYS_FREAD_UNLOCKED = 0xC7B +- SYS_FREEIFADDRS = 0xCE6 +- SYS_FREOPEN64 = 0xD4B +- SYS_FREOPEN64_UNLOCKED = 0xD4C +- SYS_FREOPEN_UNLOCKED = 0xCFB +- SYS_FREXPD128 = 0xBCE +- SYS_FREXPD32 = 0xBCC +- SYS_FREXPD64 = 0xBCD +- SYS_FSCANF_UNLOCKED = 0xCAF +- SYS_FSEEK64 = 0xCEF +- SYS_FSEEK64_UNLOCKED = 0xCF5 +- SYS_FSEEKO64 = 0xCF0 +- SYS_FSEEKO64_UNLOCKED = 0xCF6 +- SYS_FSEEKO_UNLOCKED = 0xCB1 +- SYS_FSEEK_UNLOCKED = 0xCB0 +- SYS_FSETPOS64 = 0xCF1 +- SYS_FSETPOS64_UNLOCKED = 0xCF7 +- SYS_FSETPOS_UNLOCKED = 0xCB3 +- SYS_FTELL64 = 0xCF2 +- SYS_FTELL64_UNLOCKED = 0xCF8 +- SYS_FTELLO64 = 0xCF3 +- SYS_FTELLO64_UNLOCKED = 0xCF9 +- SYS_FTELLO_UNLOCKED = 0xCB5 +- SYS_FTELL_UNLOCKED = 0xCB4 +- SYS_FUPDATE = 0x0B5 +- SYS_FUPDATE_UNLOCKED = 0xCB7 +- SYS_FWIDE_UNLOCKED = 0xCB8 +- SYS_FWPRINTF_UNLOCKED = 0xCB9 +- SYS_FWRITE_UNLOCKED = 0xC7A +- SYS_FWSCANF_UNLOCKED = 0xCBA +- SYS_GETDATE64 = 0xD4F +- SYS_GETIFADDRS = 0xCE7 +- SYS_GETIPV4SOURCEFILTER = 0xC77 +- SYS_GETSOURCEFILTER = 0xC79 +- SYS_GETSYNTX = 0x0FD +- SYS_GETS_UNLOCKED = 0xC7D +- SYS_GETTIMEOFDAY64 = 0xD50 +- SYS_GETWCHAR_UNLOCKED = 0xCBC +- SYS_GETWC_UNLOCKED = 0xCBB +- SYS_GMTIME = 0x0B0 +- SYS_GMTIME64 = 0xCDC +- SYS_GMTIME64_R = 0xCDD +- SYS_HYPOTD128 = 0xBD1 +- SYS_HYPOTD32 = 0xBCF +- SYS_HYPOTD64 = 0xBD0 +- SYS_ILOGBD128 = 0xBD4 +- SYS_ILOGBD32 = 0xBD2 +- SYS_ILOGBD64 = 0xBD3 +- SYS_ILOGBF = 0xA7E +- SYS_ILOGBL = 0xA81 +- SYS_INET6_IS_SRCADDR = 0xD5A +- SYS_ISBLANK = 0x0FE +- SYS_ISWALNUM = 0x0FF +- SYS_LDEXPD128 = 0xBD7 +- SYS_LDEXPD32 = 0xBD5 +- SYS_LDEXPD64 = 0xBD6 +- SYS_LGAMMAD128 = 0xBDA +- SYS_LGAMMAD32 = 0xBD8 +- SYS_LGAMMAD64 = 0xBD9 +- SYS_LIO_LISTIO = 0xC6A +- SYS_LLRINT = 0xA84 +- SYS_LLRINTD128 = 0xBDD +- SYS_LLRINTD32 = 0xBDB +- SYS_LLRINTD64 = 0xBDC +- SYS_LLRINTF = 0xA87 +- SYS_LLRINTL = 0xA8A +- SYS_LLROUND = 0xA8D +- SYS_LLROUNDD128 = 0xBE0 +- SYS_LLROUNDD32 = 0xBDE +- SYS_LLROUNDD64 = 0xBDF +- SYS_LLROUNDF = 0xA90 +- SYS_LLROUNDL = 0xA93 +- SYS_LOCALTIM = 0x0B1 +- SYS_LOCALTIME = 0x0B1 +- SYS_LOCALTIME64 = 0xCDE +- SYS_LOCALTIME64_R = 0xCDF +- SYS_LOG10D128 = 0xBE6 +- SYS_LOG10D32 = 0xBE4 +- SYS_LOG10D64 = 0xBE5 +- SYS_LOG1PD128 = 0xBE9 +- SYS_LOG1PD32 = 0xBE7 +- SYS_LOG1PD64 = 0xBE8 +- SYS_LOG2D128 = 0xBEC +- SYS_LOG2D32 = 0xBEA +- SYS_LOG2D64 = 0xBEB +- SYS_LOGBD128 = 0xBEF +- SYS_LOGBD32 = 0xBED +- SYS_LOGBD64 = 0xBEE +- SYS_LOGBF = 0xA96 +- SYS_LOGBL = 0xA99 +- SYS_LOGD128 = 0xBE3 +- SYS_LOGD32 = 0xBE1 +- SYS_LOGD64 = 0xBE2 +- SYS_LRINT = 0xA9C +- SYS_LRINTD128 = 0xBF2 +- SYS_LRINTD32 = 0xBF0 +- SYS_LRINTD64 = 0xBF1 +- SYS_LRINTF = 0xA9F +- SYS_LRINTL = 0xAA2 +- SYS_LROUNDD128 = 0xBF5 +- SYS_LROUNDD32 = 0xBF3 +- SYS_LROUNDD64 = 0xBF4 +- SYS_LROUNDL = 0xAA5 +- SYS_MBLEN = 0x0AF +- SYS_MBRTOC16 = 0xD42 +- SYS_MBRTOC32 = 0xD43 +- SYS_MEMSET = 0x0A3 +- SYS_MKTIME = 0x0AC +- SYS_MKTIME64 = 0xCE0 +- SYS_MODFD128 = 0xBF8 +- SYS_MODFD32 = 0xBF6 +- SYS_MODFD64 = 0xBF7 +- SYS_NAN = 0xAA8 +- SYS_NAND128 = 0xBFB +- SYS_NAND32 = 0xBF9 +- SYS_NAND64 = 0xBFA +- SYS_NANF = 0xAAA +- SYS_NANL = 0xAAC +- SYS_NEARBYINT = 0xAAE +- SYS_NEARBYINTD128 = 0xBFE +- SYS_NEARBYINTD32 = 0xBFC +- SYS_NEARBYINTD64 = 0xBFD +- SYS_NEARBYINTF = 0xAB1 +- SYS_NEARBYINTL = 0xAB4 +- SYS_NEXTAFTERD128 = 0xC01 +- SYS_NEXTAFTERD32 = 0xBFF +- SYS_NEXTAFTERD64 = 0xC00 +- SYS_NEXTAFTERF = 0xAB7 +- SYS_NEXTAFTERL = 0xABA +- SYS_NEXTTOWARD = 0xABD +- SYS_NEXTTOWARDD128 = 0xC04 +- SYS_NEXTTOWARDD32 = 0xC02 +- SYS_NEXTTOWARDD64 = 0xC03 +- SYS_NEXTTOWARDF = 0xAC0 +- SYS_NEXTTOWARDL = 0xAC3 +- SYS_NL_LANGINFO = 0x0FC +- SYS_PERROR_UNLOCKED = 0xCBD +- SYS_POSIX_FALLOCATE = 0xCE8 +- SYS_POSIX_MEMALIGN = 0xCE9 +- SYS_POSIX_OPENPT = 0xC66 +- SYS_POWD128 = 0xC07 +- SYS_POWD32 = 0xC05 +- SYS_POWD64 = 0xC06 +- SYS_PRINTF_UNLOCKED = 0xCBE +- SYS_PSELECT = 0xC67 +- SYS_PTHREAD_ATTR_GETSTACK = 0xB3E +- SYS_PTHREAD_ATTR_SETSTACK = 0xB3F +- SYS_PTHREAD_SECURITY_APPLID_NP = 0xCE4 +- SYS_PUTS_UNLOCKED = 0xC7F +- SYS_PUTWCHAR_UNLOCKED = 0xCC0 +- SYS_PUTWC_UNLOCKED = 0xCBF +- SYS_QUANTEXPD128 = 0xD46 +- SYS_QUANTEXPD32 = 0xD44 +- SYS_QUANTEXPD64 = 0xD45 +- SYS_QUANTIZED128 = 0xC0A +- SYS_QUANTIZED32 = 0xC08 +- SYS_QUANTIZED64 = 0xC09 +- SYS_REMAINDERD128 = 0xC0D +- SYS_REMAINDERD32 = 0xC0B +- SYS_REMAINDERD64 = 0xC0C +- SYS_RESIZE_ALLOC = 0xCEB +- SYS_REWIND_UNLOCKED = 0xCC1 +- SYS_RINTD128 = 0xC13 +- SYS_RINTD32 = 0xC11 +- SYS_RINTD64 = 0xC12 +- SYS_RINTF = 0xACB +- SYS_RINTL = 0xACD +- SYS_ROUND = 0xACF +- SYS_ROUNDD128 = 0xC16 +- SYS_ROUNDD32 = 0xC14 +- SYS_ROUNDD64 = 0xC15 +- SYS_ROUNDF = 0xAD2 +- SYS_ROUNDL = 0xAD5 +- SYS_SAMEQUANTUMD128 = 0xC19 +- SYS_SAMEQUANTUMD32 = 0xC17 +- SYS_SAMEQUANTUMD64 = 0xC18 +- SYS_SCALBLN = 0xAD8 +- SYS_SCALBLND128 = 0xC1C +- SYS_SCALBLND32 = 0xC1A +- SYS_SCALBLND64 = 0xC1B +- SYS_SCALBLNF = 0xADB +- SYS_SCALBLNL = 0xADE +- SYS_SCALBND128 = 0xC1F +- SYS_SCALBND32 = 0xC1D +- SYS_SCALBND64 = 0xC1E +- SYS_SCALBNF = 0xAE3 +- SYS_SCALBNL = 0xAE6 +- SYS_SCANF_UNLOCKED = 0xCC2 +- SYS_SCHED_YIELD = 0xB32 +- SYS_SETENV = 0x0C8 +- SYS_SETIPV4SOURCEFILTER = 0xC76 +- SYS_SETSOURCEFILTER = 0xC78 +- SYS_SHM_OPEN = 0xC8C +- SYS_SHM_UNLINK = 0xC8D +- SYS_SIND128 = 0xC22 +- SYS_SIND32 = 0xC20 +- SYS_SIND64 = 0xC21 +- SYS_SINHD128 = 0xC25 +- SYS_SINHD32 = 0xC23 +- SYS_SINHD64 = 0xC24 +- SYS_SIZEOF_ALLOC = 0xCEA +- SYS_SOCKATMARK = 0xC68 +- SYS_SQRTD128 = 0xC28 +- SYS_SQRTD32 = 0xC26 +- SYS_SQRTD64 = 0xC27 +- SYS_STRCHR = 0x0A0 +- SYS_STRCSPN = 0x0A1 +- SYS_STRERROR = 0x0A8 +- SYS_STRERROR_R = 0xB33 +- SYS_STRFTIME = 0x0B2 +- SYS_STRLEN = 0x0A9 +- SYS_STRPBRK = 0x0A2 +- SYS_STRSPN = 0x0A4 +- SYS_STRSTR = 0x0A5 +- SYS_STRTOD128 = 0xC2B +- SYS_STRTOD32 = 0xC29 +- SYS_STRTOD64 = 0xC2A +- SYS_STRTOK = 0x0A6 +- SYS_TAND128 = 0xC2E +- SYS_TAND32 = 0xC2C +- SYS_TAND64 = 0xC2D +- SYS_TANHD128 = 0xC31 +- SYS_TANHD32 = 0xC2F +- SYS_TANHD64 = 0xC30 +- SYS_TGAMMAD128 = 0xC34 +- SYS_TGAMMAD32 = 0xC32 +- SYS_TGAMMAD64 = 0xC33 +- SYS_TIME = 0x0AD +- SYS_TIME64 = 0xCE1 +- SYS_TMPFILE64 = 0xD4D +- SYS_TMPFILE64_UNLOCKED = 0xD4E +- SYS_TMPFILE_UNLOCKED = 0xCFD +- SYS_TRUNCD128 = 0xC40 +- SYS_TRUNCD32 = 0xC3E +- SYS_TRUNCD64 = 0xC3F +- SYS_UNGETC_UNLOCKED = 0xCC3 +- SYS_UNGETWC_UNLOCKED = 0xCC4 +- SYS_UNSETENV = 0xB34 +- SYS_VFPRINTF_UNLOCKED = 0xCC5 +- SYS_VFSCANF_UNLOCKED = 0xCC7 +- SYS_VFWPRINTF_UNLOCKED = 0xCC9 +- SYS_VFWSCANF_UNLOCKED = 0xCCB +- SYS_VPRINTF_UNLOCKED = 0xCCD +- SYS_VSCANF_UNLOCKED = 0xCCF +- SYS_VWPRINTF_UNLOCKED = 0xCD1 +- SYS_VWSCANF_UNLOCKED = 0xCD3 +- SYS_WCSTOD128 = 0xC43 +- SYS_WCSTOD32 = 0xC41 +- SYS_WCSTOD64 = 0xC42 +- SYS_WPRINTF_UNLOCKED = 0xCD5 +- SYS_WSCANF_UNLOCKED = 0xCD6 +- SYS__FLUSHLBF = 0xD68 +- SYS__FLUSHLBF_UNLOCKED = 0xD6F +- SYS___ACOSHF_H = 0xA54 +- SYS___ACOSHL_H = 0xA55 +- SYS___ASINHF_H = 0xA56 +- SYS___ASINHL_H = 0xA57 +- SYS___ATANPID128 = 0xC6D +- SYS___ATANPID32 = 0xC6B +- SYS___ATANPID64 = 0xC6C +- SYS___CBRTF_H = 0xA58 +- SYS___CBRTL_H = 0xA59 +- SYS___CDUMP = 0x0C4 +- SYS___CLASS = 0xAFA +- SYS___CLASS2 = 0xB99 +- SYS___CLASS2D128 = 0xC99 +- SYS___CLASS2D32 = 0xC97 +- SYS___CLASS2D64 = 0xC98 +- SYS___CLASS2F = 0xC91 +- SYS___CLASS2F_B = 0xC93 +- SYS___CLASS2F_H = 0xC94 +- SYS___CLASS2L = 0xC92 +- SYS___CLASS2L_B = 0xC95 +- SYS___CLASS2L_H = 0xC96 +- SYS___CLASS2_B = 0xB9A +- SYS___CLASS2_H = 0xB9B +- SYS___CLASS_B = 0xAFB +- SYS___CLASS_H = 0xAFC +- SYS___CLOGL_B = 0xA01 +- SYS___CLOGL_H = 0xA02 +- SYS___CLRENV = 0x0C9 +- SYS___CLRMF = 0x0BD +- SYS___CODEPAGE_INFO = 0xC64 +- SYS___CONJF_B = 0xA07 +- SYS___CONJF_H = 0xA08 +- SYS___CONJL_B = 0xA0A +- SYS___CONJL_H = 0xA0B +- SYS___CONJ_B = 0xA04 +- SYS___CONJ_H = 0xA05 +- SYS___COPYSIGN_B = 0xA5A +- SYS___COPYSIGN_H = 0xAF5 +- SYS___COSPID128 = 0xC70 +- SYS___COSPID32 = 0xC6E +- SYS___COSPID64 = 0xC6F +- SYS___CPOWF_B = 0xA10 +- SYS___CPOWF_H = 0xA11 +- SYS___CPOWL_B = 0xA13 +- SYS___CPOWL_H = 0xA14 +- SYS___CPOW_B = 0xA0D +- SYS___CPOW_H = 0xA0E +- SYS___CPROJF_B = 0xA19 +- SYS___CPROJF_H = 0xA1A +- SYS___CPROJL_B = 0xA1C +- SYS___CPROJL_H = 0xA1D +- SYS___CPROJ_B = 0xA16 +- SYS___CPROJ_H = 0xA17 +- SYS___CREALF_B = 0xA22 +- SYS___CREALF_H = 0xA23 +- SYS___CREALL_B = 0xA25 +- SYS___CREALL_H = 0xA26 +- SYS___CREAL_B = 0xA1F +- SYS___CREAL_H = 0xA20 +- SYS___CSINF_B = 0xA2B +- SYS___CSINF_H = 0xA2C +- SYS___CSINHF_B = 0xA34 +- SYS___CSINHF_H = 0xA35 +- SYS___CSINHL_B = 0xA37 +- SYS___CSINHL_H = 0xA38 +- SYS___CSINH_B = 0xA31 +- SYS___CSINH_H = 0xA32 +- SYS___CSINL_B = 0xA2E +- SYS___CSINL_H = 0xA2F +- SYS___CSIN_B = 0xA28 +- SYS___CSIN_H = 0xA29 +- SYS___CSNAP = 0x0C5 +- SYS___CSQRTF_B = 0xA3D +- SYS___CSQRTF_H = 0xA3E +- SYS___CSQRTL_B = 0xA40 +- SYS___CSQRTL_H = 0xA41 +- SYS___CSQRT_B = 0xA3A +- SYS___CSQRT_H = 0xA3B +- SYS___CTANF_B = 0xA46 +- SYS___CTANF_H = 0xA47 +- SYS___CTANHF_B = 0xA4F +- SYS___CTANHF_H = 0xA50 +- SYS___CTANHL_B = 0xA52 +- SYS___CTANHL_H = 0xA53 +- SYS___CTANH_B = 0xA4C +- SYS___CTANH_H = 0xA4D +- SYS___CTANL_B = 0xA49 +- SYS___CTANL_H = 0xA4A +- SYS___CTAN_B = 0xA43 +- SYS___CTAN_H = 0xA44 +- SYS___CTEST = 0x0C7 +- SYS___CTRACE = 0x0C6 +- SYS___D1TOP = 0xC9B +- SYS___D2TOP = 0xC9C +- SYS___D4TOP = 0xC9D +- SYS___DYNALL = 0x0C3 +- SYS___DYNFRE = 0x0C2 +- SYS___EXP2F_H = 0xA5E +- SYS___EXP2L_H = 0xA5F +- SYS___EXP2_H = 0xA5D +- SYS___EXPM1F_H = 0xA5B +- SYS___EXPM1L_H = 0xA5C +- SYS___FBUFSIZE = 0xD60 +- SYS___FLBF = 0xD62 +- SYS___FLDATA = 0x0C1 +- SYS___FMAF_B = 0xA67 +- SYS___FMAF_H = 0xA68 +- SYS___FMAL_B = 0xA6A +- SYS___FMAL_H = 0xA6B +- SYS___FMAXF_B = 0xA70 +- SYS___FMAXF_H = 0xA71 +- SYS___FMAXL_B = 0xA73 +- SYS___FMAXL_H = 0xA74 +- SYS___FMAX_B = 0xA6D +- SYS___FMAX_H = 0xA6E +- SYS___FMA_B = 0xA64 +- SYS___FMA_H = 0xA65 +- SYS___FMINF_B = 0xA79 +- SYS___FMINF_H = 0xA7A +- SYS___FMINL_B = 0xA7C +- SYS___FMINL_H = 0xA7D +- SYS___FMIN_B = 0xA76 +- SYS___FMIN_H = 0xA77 +- SYS___FPENDING = 0xD61 +- SYS___FPENDING_UNLOCKED = 0xD6C +- SYS___FPURGE = 0xD69 +- SYS___FPURGE_UNLOCKED = 0xD70 +- SYS___FP_CAST_D = 0xBCB +- SYS___FREADABLE = 0xD63 +- SYS___FREADAHEAD = 0xD6A +- SYS___FREADAHEAD_UNLOCKED = 0xD71 +- SYS___FREADING = 0xD65 +- SYS___FREADING_UNLOCKED = 0xD6D +- SYS___FSEEK2 = 0xB3C +- SYS___FSETERR = 0xD6B +- SYS___FSETLOCKING = 0xD67 +- SYS___FTCHEP = 0x0BF +- SYS___FTELL2 = 0xB3B +- SYS___FUPDT = 0x0B5 +- SYS___FWRITABLE = 0xD64 +- SYS___FWRITING = 0xD66 +- SYS___FWRITING_UNLOCKED = 0xD6E +- SYS___GETCB = 0x0B4 +- SYS___GETGRGID1 = 0xD5B +- SYS___GETGRNAM1 = 0xD5C +- SYS___GETTHENT = 0xCE5 +- SYS___GETTOD = 0xD3E +- SYS___HYPOTF_H = 0xAF6 +- SYS___HYPOTL_H = 0xAF7 +- SYS___ILOGBF_B = 0xA7F +- SYS___ILOGBF_H = 0xA80 +- SYS___ILOGBL_B = 0xA82 +- SYS___ILOGBL_H = 0xA83 +- SYS___ISBLANK_A = 0xB2E +- SYS___ISBLNK = 0x0FE +- SYS___ISWBLANK_A = 0xB2F +- SYS___LE_CEEGTJS = 0xD72 +- SYS___LE_TRACEBACK = 0xB7A +- SYS___LGAMMAL_H = 0xA62 +- SYS___LGAMMA_B_C99 = 0xB39 +- SYS___LGAMMA_H_C99 = 0xB38 +- SYS___LGAMMA_R_C99 = 0xB3A +- SYS___LLRINTF_B = 0xA88 +- SYS___LLRINTF_H = 0xA89 +- SYS___LLRINTL_B = 0xA8B +- SYS___LLRINTL_H = 0xA8C +- SYS___LLRINT_B = 0xA85 +- SYS___LLRINT_H = 0xA86 +- SYS___LLROUNDF_B = 0xA91 +- SYS___LLROUNDF_H = 0xA92 +- SYS___LLROUNDL_B = 0xA94 +- SYS___LLROUNDL_H = 0xA95 +- SYS___LLROUND_B = 0xA8E +- SYS___LLROUND_H = 0xA8F +- SYS___LOCALE_CTL = 0xD47 +- SYS___LOG1PF_H = 0xA60 +- SYS___LOG1PL_H = 0xA61 +- SYS___LOGBF_B = 0xA97 +- SYS___LOGBF_H = 0xA98 +- SYS___LOGBL_B = 0xA9A +- SYS___LOGBL_H = 0xA9B +- SYS___LOGIN_APPLID = 0xCE2 +- SYS___LRINTF_B = 0xAA0 +- SYS___LRINTF_H = 0xAA1 +- SYS___LRINTL_B = 0xAA3 +- SYS___LRINTL_H = 0xAA4 +- SYS___LRINT_B = 0xA9D +- SYS___LRINT_H = 0xA9E +- SYS___LROUNDF_FIXUP = 0xB31 +- SYS___LROUNDL_B = 0xAA6 +- SYS___LROUNDL_H = 0xAA7 +- SYS___LROUND_FIXUP = 0xB30 +- SYS___MOSERVICES = 0xD3D +- SYS___MUST_STAY_CLEAN = 0xB7C +- SYS___NANF_B = 0xAAB +- SYS___NANL_B = 0xAAD +- SYS___NAN_B = 0xAA9 +- SYS___NEARBYINTF_B = 0xAB2 +- SYS___NEARBYINTF_H = 0xAB3 +- SYS___NEARBYINTL_B = 0xAB5 +- SYS___NEARBYINTL_H = 0xAB6 +- SYS___NEARBYINT_B = 0xAAF +- SYS___NEARBYINT_H = 0xAB0 +- SYS___NEXTAFTERF_B = 0xAB8 +- SYS___NEXTAFTERF_H = 0xAB9 +- SYS___NEXTAFTERL_B = 0xABB +- SYS___NEXTAFTERL_H = 0xABC +- SYS___NEXTTOWARDF_B = 0xAC1 +- SYS___NEXTTOWARDF_H = 0xAC2 +- SYS___NEXTTOWARDL_B = 0xAC4 +- SYS___NEXTTOWARDL_H = 0xAC5 +- SYS___NEXTTOWARD_B = 0xABE +- SYS___NEXTTOWARD_H = 0xABF +- SYS___O_ENV = 0xB7D +- SYS___PASSWD_APPLID = 0xCE3 +- SYS___PTOD1 = 0xC9E +- SYS___PTOD2 = 0xC9F +- SYS___PTOD4 = 0xCA0 +- SYS___REGCOMP_STD = 0x0EA +- SYS___REMAINDERF_H = 0xAC6 +- SYS___REMAINDERL_H = 0xAC7 +- SYS___REMQUOD128 = 0xC10 +- SYS___REMQUOD32 = 0xC0E +- SYS___REMQUOD64 = 0xC0F +- SYS___REMQUOF_H = 0xAC9 +- SYS___REMQUOL_H = 0xACA +- SYS___REMQUO_H = 0xAC8 +- SYS___RINTF_B = 0xACC +- SYS___RINTL_B = 0xACE +- SYS___ROUNDF_B = 0xAD3 +- SYS___ROUNDF_H = 0xAD4 +- SYS___ROUNDL_B = 0xAD6 +- SYS___ROUNDL_H = 0xAD7 +- SYS___ROUND_B = 0xAD0 +- SYS___ROUND_H = 0xAD1 +- SYS___SCALBLNF_B = 0xADC +- SYS___SCALBLNF_H = 0xADD +- SYS___SCALBLNL_B = 0xADF +- SYS___SCALBLNL_H = 0xAE0 +- SYS___SCALBLN_B = 0xAD9 +- SYS___SCALBLN_H = 0xADA +- SYS___SCALBNF_B = 0xAE4 +- SYS___SCALBNF_H = 0xAE5 +- SYS___SCALBNL_B = 0xAE7 +- SYS___SCALBNL_H = 0xAE8 +- SYS___SCALBN_B = 0xAE1 +- SYS___SCALBN_H = 0xAE2 +- SYS___SETENV = 0x0C8 +- SYS___SINPID128 = 0xC73 +- SYS___SINPID32 = 0xC71 +- SYS___SINPID64 = 0xC72 +- SYS___SMF_RECORD2 = 0xD48 +- SYS___STATIC_REINIT = 0xB3D +- SYS___TGAMMAF_H_C99 = 0xB79 +- SYS___TGAMMAL_H = 0xAE9 +- SYS___TGAMMA_H_C99 = 0xB78 +- SYS___TOCSNAME2 = 0xC9A +- SYS_CEIL = 0x01F +- SYS_CHAUDIT = 0x1E0 +- SYS_EXP = 0x01A +- SYS_FCHAUDIT = 0x1E1 +- SYS_FREXP = 0x01D +- SYS_GETGROUPSBYNAME = 0x1E2 +- SYS_GETPWUID = 0x1A0 +- SYS_GETUID = 0x1A1 +- SYS_ISATTY = 0x1A3 +- SYS_KILL = 0x1A4 +- SYS_LDEXP = 0x01E +- SYS_LINK = 0x1A5 +- SYS_LOG10 = 0x01C +- SYS_LSEEK = 0x1A6 +- SYS_LSTAT = 0x1A7 +- SYS_MKDIR = 0x1A8 +- SYS_MKFIFO = 0x1A9 +- SYS_MKNOD = 0x1AA +- SYS_MODF = 0x01B +- SYS_MOUNT = 0x1AB +- SYS_OPEN = 0x1AC +- SYS_OPENDIR = 0x1AD +- SYS_PATHCONF = 0x1AE +- SYS_PAUSE = 0x1AF +- SYS_PIPE = 0x1B0 +- SYS_PTHREAD_ATTR_DESTROY = 0x1E7 +- SYS_PTHREAD_ATTR_GETDETACHSTATE = 0x1EB +- SYS_PTHREAD_ATTR_GETSTACKSIZE = 0x1E9 +- SYS_PTHREAD_ATTR_GETWEIGHT_NP = 0x1ED +- SYS_PTHREAD_ATTR_INIT = 0x1E6 +- SYS_PTHREAD_ATTR_SETDETACHSTATE = 0x1EA +- SYS_PTHREAD_ATTR_SETSTACKSIZE = 0x1E8 +- SYS_PTHREAD_ATTR_SETWEIGHT_NP = 0x1EC +- SYS_PTHREAD_CANCEL = 0x1EE +- SYS_PTHREAD_CLEANUP_POP = 0x1F0 +- SYS_PTHREAD_CLEANUP_PUSH = 0x1EF +- SYS_PTHREAD_CONDATTR_DESTROY = 0x1F2 +- SYS_PTHREAD_CONDATTR_INIT = 0x1F1 +- SYS_PTHREAD_COND_BROADCAST = 0x1F6 +- SYS_PTHREAD_COND_DESTROY = 0x1F4 +- SYS_PTHREAD_COND_INIT = 0x1F3 +- SYS_PTHREAD_COND_SIGNAL = 0x1F5 +- SYS_PTHREAD_COND_TIMEDWAIT = 0x1F8 +- SYS_PTHREAD_COND_WAIT = 0x1F7 +- SYS_PTHREAD_CREATE = 0x1F9 +- SYS_PTHREAD_DETACH = 0x1FA +- SYS_PTHREAD_EQUAL = 0x1FB +- SYS_PTHREAD_EXIT = 0x1E4 +- SYS_PTHREAD_GETSPECIFIC = 0x1FC +- SYS_PTHREAD_JOIN = 0x1FD +- SYS_PTHREAD_KEY_CREATE = 0x1FE +- SYS_PTHREAD_KILL = 0x1E5 +- SYS_PTHREAD_MUTEXATTR_INIT = 0x1FF +- SYS_READ = 0x1B2 +- SYS_READDIR = 0x1B3 +- SYS_READLINK = 0x1B4 +- SYS_REWINDDIR = 0x1B5 +- SYS_RMDIR = 0x1B6 +- SYS_SETEGID = 0x1B7 +- SYS_SETEUID = 0x1B8 +- SYS_SETGID = 0x1B9 +- SYS_SETPGID = 0x1BA +- SYS_SETSID = 0x1BB +- SYS_SETUID = 0x1BC +- SYS_SIGACTION = 0x1BD +- SYS_SIGADDSET = 0x1BE +- SYS_SIGDELSET = 0x1BF +- SYS_SIGEMPTYSET = 0x1C0 +- SYS_SIGFILLSET = 0x1C1 +- SYS_SIGISMEMBER = 0x1C2 +- SYS_SIGLONGJMP = 0x1C3 +- SYS_SIGPENDING = 0x1C4 +- SYS_SIGPROCMASK = 0x1C5 +- SYS_SIGSETJMP = 0x1C6 +- SYS_SIGSUSPEND = 0x1C7 +- SYS_SIGWAIT = 0x1E3 +- SYS_SLEEP = 0x1C8 +- SYS_STAT = 0x1C9 +- SYS_SYMLINK = 0x1CB +- SYS_SYSCONF = 0x1CC +- SYS_TCDRAIN = 0x1CD +- SYS_TCFLOW = 0x1CE +- SYS_TCFLUSH = 0x1CF +- SYS_TCGETATTR = 0x1D0 +- SYS_TCGETPGRP = 0x1D1 +- SYS_TCSENDBREAK = 0x1D2 +- SYS_TCSETATTR = 0x1D3 +- SYS_TCSETPGRP = 0x1D4 +- SYS_TIMES = 0x1D5 +- SYS_TTYNAME = 0x1D6 +- SYS_TZSET = 0x1D7 +- SYS_UMASK = 0x1D8 +- SYS_UMOUNT = 0x1D9 +- SYS_UNAME = 0x1DA +- SYS_UNLINK = 0x1DB +- SYS_UTIME = 0x1DC +- SYS_WAIT = 0x1DD +- SYS_WAITPID = 0x1DE +- SYS_WRITE = 0x1DF +- SYS_W_GETPSENT = 0x1B1 +- SYS_W_IOCTL = 0x1A2 +- SYS_W_STATFS = 0x1CA +- SYS_A64L = 0x2EF +- SYS_BCMP = 0x2B9 +- SYS_BCOPY = 0x2BA +- SYS_BZERO = 0x2BB +- SYS_CATCLOSE = 0x2B6 +- SYS_CATGETS = 0x2B7 +- SYS_CATOPEN = 0x2B8 +- SYS_CRYPT = 0x2AC +- SYS_DBM_CLEARERR = 0x2F7 +- SYS_DBM_CLOSE = 0x2F8 +- SYS_DBM_DELETE = 0x2F9 +- SYS_DBM_ERROR = 0x2FA +- SYS_DBM_FETCH = 0x2FB +- SYS_DBM_FIRSTKEY = 0x2FC +- SYS_DBM_NEXTKEY = 0x2FD +- SYS_DBM_OPEN = 0x2FE +- SYS_DBM_STORE = 0x2FF +- SYS_DRAND48 = 0x2B2 +- SYS_ENCRYPT = 0x2AD +- SYS_ENDUTXENT = 0x2E1 +- SYS_ERAND48 = 0x2B3 +- SYS_ERF = 0x02C +- SYS_ERFC = 0x02D +- SYS_FCHDIR = 0x2D9 +- SYS_FFS = 0x2BC +- SYS_FMTMSG = 0x2E5 +- SYS_FSTATVFS = 0x2B4 +- SYS_FTIME = 0x2F5 +- SYS_GAMMA = 0x02E +- SYS_GETDATE = 0x2A6 +- SYS_GETPAGESIZE = 0x2D8 +- SYS_GETTIMEOFDAY = 0x2F6 +- SYS_GETUTXENT = 0x2E0 +- SYS_GETUTXID = 0x2E2 +- SYS_GETUTXLINE = 0x2E3 +- SYS_HCREATE = 0x2C6 +- SYS_HDESTROY = 0x2C7 +- SYS_HSEARCH = 0x2C8 +- SYS_HYPOT = 0x02B +- SYS_INDEX = 0x2BD +- SYS_INITSTATE = 0x2C2 +- SYS_INSQUE = 0x2CF +- SYS_ISASCII = 0x2ED +- SYS_JRAND48 = 0x2E6 +- SYS_L64A = 0x2F0 +- SYS_LCONG48 = 0x2EA +- SYS_LFIND = 0x2C9 +- SYS_LRAND48 = 0x2E7 +- SYS_LSEARCH = 0x2CA +- SYS_MEMCCPY = 0x2D4 +- SYS_MRAND48 = 0x2E8 +- SYS_NRAND48 = 0x2E9 +- SYS_PCLOSE = 0x2D2 +- SYS_POPEN = 0x2D1 +- SYS_PUTUTXLINE = 0x2E4 +- SYS_RANDOM = 0x2C4 +- SYS_REMQUE = 0x2D0 +- SYS_RINDEX = 0x2BE +- SYS_SEED48 = 0x2EC +- SYS_SETKEY = 0x2AE +- SYS_SETSTATE = 0x2C3 +- SYS_SETUTXENT = 0x2DF +- SYS_SRAND48 = 0x2EB +- SYS_SRANDOM = 0x2C5 +- SYS_STATVFS = 0x2B5 +- SYS_STRCASECMP = 0x2BF +- SYS_STRDUP = 0x2C0 +- SYS_STRNCASECMP = 0x2C1 +- SYS_SWAB = 0x2D3 +- SYS_TDELETE = 0x2CB +- SYS_TFIND = 0x2CC +- SYS_TOASCII = 0x2EE +- SYS_TSEARCH = 0x2CD +- SYS_TWALK = 0x2CE +- SYS_UALARM = 0x2F1 +- SYS_USLEEP = 0x2F2 +- SYS_WAIT3 = 0x2A7 +- SYS_WAITID = 0x2A8 +- SYS_Y1 = 0x02A +- SYS___ATOE = 0x2DB +- SYS___ATOE_L = 0x2DC +- SYS___CATTRM = 0x2A9 +- SYS___CNVBLK = 0x2AF +- SYS___CRYTRM = 0x2B0 +- SYS___DLGHT = 0x2A1 +- SYS___ECRTRM = 0x2B1 +- SYS___ETOA = 0x2DD +- SYS___ETOA_L = 0x2DE +- SYS___GDTRM = 0x2AA +- SYS___OCLCK = 0x2DA +- SYS___OPARGF = 0x2A2 +- SYS___OPERRF = 0x2A5 +- SYS___OPINDF = 0x2A4 +- SYS___OPOPTF = 0x2A3 +- SYS___RNDTRM = 0x2AB +- SYS___SRCTRM = 0x2F4 +- SYS___TZONE = 0x2A0 +- SYS___UTXTRM = 0x2F3 +- SYS_ASIN = 0x03E +- SYS_ISXDIGIT = 0x03B +- SYS_SETLOCAL = 0x03A +- SYS_SETLOCALE = 0x03A +- SYS_SIN = 0x03F +- SYS_TOLOWER = 0x03C +- SYS_TOUPPER = 0x03D +- SYS_ACCEPT_AND_RECV = 0x4F7 +- SYS_ATOL = 0x04E +- SYS_CHECKSCH = 0x4BC +- SYS_CHECKSCHENV = 0x4BC +- SYS_CLEARERR = 0x04C +- SYS_CONNECTS = 0x4B5 +- SYS_CONNECTSERVER = 0x4B5 +- SYS_CONNECTW = 0x4B4 +- SYS_CONNECTWORKMGR = 0x4B4 +- SYS_CONTINUE = 0x4B3 +- SYS_CONTINUEWORKUNIT = 0x4B3 +- SYS_COPYSIGN = 0x4C2 +- SYS_CREATEWO = 0x4B2 +- SYS_CREATEWORKUNIT = 0x4B2 +- SYS_DELETEWO = 0x4B9 +- SYS_DELETEWORKUNIT = 0x4B9 +- SYS_DISCONNE = 0x4B6 +- SYS_DISCONNECTSERVER = 0x4B6 +- SYS_FEOF = 0x04D +- SYS_FERROR = 0x04A +- SYS_FINITE = 0x4C8 +- SYS_GAMMA_R = 0x4E2 +- SYS_JOINWORK = 0x4B7 +- SYS_JOINWORKUNIT = 0x4B7 +- SYS_LEAVEWOR = 0x4B8 +- SYS_LEAVEWORKUNIT = 0x4B8 +- SYS_LGAMMA_R = 0x4EB +- SYS_MATHERR = 0x4D0 +- SYS_PERROR = 0x04F +- SYS_QUERYMET = 0x4BA +- SYS_QUERYMETRICS = 0x4BA +- SYS_QUERYSCH = 0x4BB +- SYS_QUERYSCHENV = 0x4BB +- SYS_REWIND = 0x04B +- SYS_SCALBN = 0x4D4 +- SYS_SIGNIFIC = 0x4D5 +- SYS_SIGNIFICAND = 0x4D5 +- SYS___ACOSH_B = 0x4DA +- SYS___ACOS_B = 0x4D9 +- SYS___ASINH_B = 0x4BE +- SYS___ASIN_B = 0x4DB +- SYS___ATAN2_B = 0x4DC +- SYS___ATANH_B = 0x4DD +- SYS___ATAN_B = 0x4BF +- SYS___CBRT_B = 0x4C0 +- SYS___CEIL_B = 0x4C1 +- SYS___COSH_B = 0x4DE +- SYS___COS_B = 0x4C3 +- SYS___DGHT = 0x4A8 +- SYS___ENVN = 0x4B0 +- SYS___ERFC_B = 0x4C5 +- SYS___ERF_B = 0x4C4 +- SYS___EXPM1_B = 0x4C6 +- SYS___EXP_B = 0x4DF +- SYS___FABS_B = 0x4C7 +- SYS___FLOOR_B = 0x4C9 +- SYS___FMOD_B = 0x4E0 +- SYS___FP_SETMODE = 0x4F8 +- SYS___FREXP_B = 0x4CA +- SYS___GAMMA_B = 0x4E1 +- SYS___GDRR = 0x4A1 +- SYS___HRRNO = 0x4A2 +- SYS___HYPOT_B = 0x4E3 +- SYS___ILOGB_B = 0x4CB +- SYS___ISNAN_B = 0x4CC +- SYS___J0_B = 0x4E4 +- SYS___J1_B = 0x4E6 +- SYS___JN_B = 0x4E8 +- SYS___LDEXP_B = 0x4CD +- SYS___LGAMMA_B = 0x4EA +- SYS___LOG10_B = 0x4ED +- SYS___LOG1P_B = 0x4CE +- SYS___LOGB_B = 0x4CF +- SYS___LOGIN = 0x4F5 +- SYS___LOG_B = 0x4EC +- SYS___MLOCKALL = 0x4B1 +- SYS___MODF_B = 0x4D1 +- SYS___NEXTAFTER_B = 0x4D2 +- SYS___OPENDIR2 = 0x4F3 +- SYS___OPEN_STAT = 0x4F6 +- SYS___OPND = 0x4A5 +- SYS___OPPT = 0x4A6 +- SYS___OPRG = 0x4A3 +- SYS___OPRR = 0x4A4 +- SYS___PID_AFFINITY = 0x4BD +- SYS___POW_B = 0x4EE +- SYS___READDIR2 = 0x4F4 +- SYS___REMAINDER_B = 0x4EF +- SYS___RINT_B = 0x4D3 +- SYS___SCALB_B = 0x4F0 +- SYS___SIGACTIONSET = 0x4FB +- SYS___SIGGM = 0x4A7 +- SYS___SINH_B = 0x4F1 +- SYS___SIN_B = 0x4D6 +- SYS___SQRT_B = 0x4F2 +- SYS___TANH_B = 0x4D8 +- SYS___TAN_B = 0x4D7 +- SYS___TRRNO = 0x4AF +- SYS___TZNE = 0x4A9 +- SYS___TZZN = 0x4AA +- SYS___UCREATE = 0x4FC +- SYS___UFREE = 0x4FE +- SYS___UHEAPREPORT = 0x4FF +- SYS___UMALLOC = 0x4FD +- SYS___Y0_B = 0x4E5 +- SYS___Y1_B = 0x4E7 +- SYS___YN_B = 0x4E9 +- SYS_ABORT = 0x05C +- SYS_ASCTIME_R = 0x5E0 +- SYS_ATEXIT = 0x05D +- SYS_CONNECTE = 0x5AE +- SYS_CONNECTEXPORTIMPORT = 0x5AE +- SYS_CTIME_R = 0x5E1 +- SYS_DN_COMP = 0x5DF +- SYS_DN_EXPAND = 0x5DD +- SYS_DN_SKIPNAME = 0x5DE +- SYS_EXIT = 0x05A +- SYS_EXPORTWO = 0x5A1 +- SYS_EXPORTWORKUNIT = 0x5A1 +- SYS_EXTRACTW = 0x5A5 +- SYS_EXTRACTWORKUNIT = 0x5A5 +- SYS_FSEEKO = 0x5C9 +- SYS_FTELLO = 0x5C8 +- SYS_GETGRGID_R = 0x5E7 +- SYS_GETGRNAM_R = 0x5E8 +- SYS_GETLOGIN_R = 0x5E9 +- SYS_GETPWNAM_R = 0x5EA +- SYS_GETPWUID_R = 0x5EB +- SYS_GMTIME_R = 0x5E2 +- SYS_IMPORTWO = 0x5A3 +- SYS_IMPORTWORKUNIT = 0x5A3 +- SYS_INET_NTOP = 0x5D3 +- SYS_INET_PTON = 0x5D4 +- SYS_LLABS = 0x5CE +- SYS_LLDIV = 0x5CB +- SYS_LOCALTIME_R = 0x5E3 +- SYS_PTHREAD_ATFORK = 0x5ED +- SYS_PTHREAD_ATTR_GETDETACHSTATE_U98 = 0x5FB +- SYS_PTHREAD_ATTR_GETGUARDSIZE = 0x5EE +- SYS_PTHREAD_ATTR_GETSCHEDPARAM = 0x5F9 +- SYS_PTHREAD_ATTR_GETSTACKADDR = 0x5EF +- SYS_PTHREAD_ATTR_SETDETACHSTATE_U98 = 0x5FC +- SYS_PTHREAD_ATTR_SETGUARDSIZE = 0x5F0 +- SYS_PTHREAD_ATTR_SETSCHEDPARAM = 0x5FA +- SYS_PTHREAD_ATTR_SETSTACKADDR = 0x5F1 +- SYS_PTHREAD_CONDATTR_GETPSHARED = 0x5F2 +- SYS_PTHREAD_CONDATTR_SETPSHARED = 0x5F3 +- SYS_PTHREAD_DETACH_U98 = 0x5FD +- SYS_PTHREAD_GETCONCURRENCY = 0x5F4 +- SYS_PTHREAD_GETSPECIFIC_U98 = 0x5FE +- SYS_PTHREAD_KEY_DELETE = 0x5F5 +- SYS_PTHREAD_SETCANCELSTATE = 0x5FF +- SYS_PTHREAD_SETCONCURRENCY = 0x5F6 +- SYS_PTHREAD_SIGMASK = 0x5F7 +- SYS_QUERYENC = 0x5AD +- SYS_QUERYWORKUNITCLASSIFICATION = 0x5AD +- SYS_RAISE = 0x05E +- SYS_RAND_R = 0x5E4 +- SYS_READDIR_R = 0x5E6 +- SYS_REALLOC = 0x05B +- SYS_RES_INIT = 0x5D8 +- SYS_RES_MKQUERY = 0x5D7 +- SYS_RES_QUERY = 0x5D9 +- SYS_RES_QUERYDOMAIN = 0x5DC +- SYS_RES_SEARCH = 0x5DA +- SYS_RES_SEND = 0x5DB +- SYS_SETJMP = 0x05F +- SYS_SIGQUEUE = 0x5A9 +- SYS_STRTOK_R = 0x5E5 +- SYS_STRTOLL = 0x5B0 +- SYS_STRTOULL = 0x5B1 +- SYS_TTYNAME_R = 0x5EC +- SYS_UNDOEXPO = 0x5A2 +- SYS_UNDOEXPORTWORKUNIT = 0x5A2 +- SYS_UNDOIMPO = 0x5A4 +- SYS_UNDOIMPORTWORKUNIT = 0x5A4 +- SYS_WCSTOLL = 0x5CC +- SYS_WCSTOULL = 0x5CD +- SYS___ABORT = 0x05C +- SYS___CONSOLE2 = 0x5D2 +- SYS___CPL = 0x5A6 +- SYS___DISCARDDATA = 0x5F8 +- SYS___DSA_PREV = 0x5B2 +- SYS___EP_FIND = 0x5B3 +- SYS___FP_SWAPMODE = 0x5AF +- SYS___GETUSERID = 0x5AB +- SYS___GET_CPUID = 0x5B9 +- SYS___GET_SYSTEM_SETTINGS = 0x5BA +- SYS___IPDOMAINNAME = 0x5AC +- SYS___MAP_INIT = 0x5A7 +- SYS___MAP_SERVICE = 0x5A8 +- SYS___MOUNT = 0x5AA +- SYS___MSGRCV_TIMED = 0x5B7 +- SYS___RES = 0x5D6 +- SYS___SEMOP_TIMED = 0x5B8 +- SYS___SERVER_THREADS_QUERY = 0x5B4 +- SYS_FPRINTF = 0x06D +- SYS_FSCANF = 0x06A +- SYS_PRINTF = 0x06F +- SYS_SETBUF = 0x06B +- SYS_SETVBUF = 0x06C +- SYS_SSCANF = 0x06E +- SYS___CATGETS_A = 0x6C0 +- SYS___CHAUDIT_A = 0x6F4 +- SYS___CHMOD_A = 0x6E8 +- SYS___COLLATE_INIT_A = 0x6AC +- SYS___CREAT_A = 0x6F6 +- SYS___CTYPE_INIT_A = 0x6AF +- SYS___DLLLOAD_A = 0x6DF +- SYS___DLLQUERYFN_A = 0x6E0 +- SYS___DLLQUERYVAR_A = 0x6E1 +- SYS___E2A_L = 0x6E3 +- SYS___EXECLE_A = 0x6A0 +- SYS___EXECLP_A = 0x6A4 +- SYS___EXECVE_A = 0x6C1 +- SYS___EXECVP_A = 0x6C2 +- SYS___EXECV_A = 0x6B1 +- SYS___FPRINTF_A = 0x6FA +- SYS___GETADDRINFO_A = 0x6BF +- SYS___GETNAMEINFO_A = 0x6C4 +- SYS___GET_WCTYPE_STD_A = 0x6AE +- SYS___ICONV_OPEN_A = 0x6DE +- SYS___IF_INDEXTONAME_A = 0x6DC +- SYS___IF_NAMETOINDEX_A = 0x6DB +- SYS___ISWCTYPE_A = 0x6B0 +- SYS___IS_WCTYPE_STD_A = 0x6B2 +- SYS___LOCALECONV_A = 0x6B8 +- SYS___LOCALECONV_STD_A = 0x6B9 +- SYS___LOCALE_INIT_A = 0x6B7 +- SYS___LSTAT_A = 0x6EE +- SYS___LSTAT_O_A = 0x6EF +- SYS___MKDIR_A = 0x6E9 +- SYS___MKFIFO_A = 0x6EC +- SYS___MKNOD_A = 0x6F0 +- SYS___MONETARY_INIT_A = 0x6BC +- SYS___MOUNT_A = 0x6F1 +- SYS___NL_CSINFO_A = 0x6D6 +- SYS___NL_LANGINFO_A = 0x6BA +- SYS___NL_LNAGINFO_STD_A = 0x6BB +- SYS___NL_MONINFO_A = 0x6D7 +- SYS___NL_NUMINFO_A = 0x6D8 +- SYS___NL_RESPINFO_A = 0x6D9 +- SYS___NL_TIMINFO_A = 0x6DA +- SYS___NUMERIC_INIT_A = 0x6C6 +- SYS___OPEN_A = 0x6F7 +- SYS___PRINTF_A = 0x6DD +- SYS___RESP_INIT_A = 0x6C7 +- SYS___RPMATCH_A = 0x6C8 +- SYS___RPMATCH_C_A = 0x6C9 +- SYS___RPMATCH_STD_A = 0x6CA +- SYS___SETLOCALE_A = 0x6F9 +- SYS___SPAWNP_A = 0x6C5 +- SYS___SPAWN_A = 0x6C3 +- SYS___SPRINTF_A = 0x6FB +- SYS___STAT_A = 0x6EA +- SYS___STAT_O_A = 0x6EB +- SYS___STRCOLL_STD_A = 0x6A1 +- SYS___STRFMON_A = 0x6BD +- SYS___STRFMON_STD_A = 0x6BE +- SYS___STRFTIME_A = 0x6CC +- SYS___STRFTIME_STD_A = 0x6CD +- SYS___STRPTIME_A = 0x6CE +- SYS___STRPTIME_STD_A = 0x6CF +- SYS___STRXFRM_A = 0x6A2 +- SYS___STRXFRM_C_A = 0x6A3 +- SYS___STRXFRM_STD_A = 0x6A5 +- SYS___SYNTAX_INIT_A = 0x6D4 +- SYS___TIME_INIT_A = 0x6CB +- SYS___TOD_INIT_A = 0x6D5 +- SYS___TOWLOWER_A = 0x6B3 +- SYS___TOWLOWER_STD_A = 0x6B4 +- SYS___TOWUPPER_A = 0x6B5 +- SYS___TOWUPPER_STD_A = 0x6B6 +- SYS___UMOUNT_A = 0x6F2 +- SYS___VFPRINTF_A = 0x6FC +- SYS___VPRINTF_A = 0x6FD +- SYS___VSPRINTF_A = 0x6FE +- SYS___VSWPRINTF_A = 0x6FF +- SYS___WCSCOLL_A = 0x6A6 +- SYS___WCSCOLL_C_A = 0x6A7 +- SYS___WCSCOLL_STD_A = 0x6A8 +- SYS___WCSFTIME_A = 0x6D0 +- SYS___WCSFTIME_STD_A = 0x6D1 +- SYS___WCSXFRM_A = 0x6A9 +- SYS___WCSXFRM_C_A = 0x6AA +- SYS___WCSXFRM_STD_A = 0x6AB +- SYS___WCTYPE_A = 0x6AD +- SYS___W_GETMNTENT_A = 0x6F5 +- SYS_____CCSIDTYPE_A = 0x6E6 +- SYS_____CHATTR_A = 0x6E2 +- SYS_____CSNAMETYPE_A = 0x6E7 +- SYS_____OPEN_STAT_A = 0x6ED +- SYS_____SPAWN2_A = 0x6D2 +- SYS_____SPAWNP2_A = 0x6D3 +- SYS_____TOCCSID_A = 0x6E4 +- SYS_____TOCSNAME_A = 0x6E5 +- SYS_ACL_FREE = 0x7FF +- SYS_ACL_INIT = 0x7FE +- SYS_FWIDE = 0x7DF +- SYS_FWPRINTF = 0x7D1 +- SYS_FWRITE = 0x07E +- SYS_FWSCANF = 0x7D5 +- SYS_GETCHAR = 0x07B +- SYS_GETS = 0x07C +- SYS_M_CREATE_LAYOUT = 0x7C9 +- SYS_M_DESTROY_LAYOUT = 0x7CA +- SYS_M_GETVALUES_LAYOUT = 0x7CB +- SYS_M_SETVALUES_LAYOUT = 0x7CC +- SYS_M_TRANSFORM_LAYOUT = 0x7CD +- SYS_M_WTRANSFORM_LAYOUT = 0x7CE +- SYS_PREAD = 0x7C7 +- SYS_PUTC = 0x07D +- SYS_PUTCHAR = 0x07A +- SYS_PUTS = 0x07F +- SYS_PWRITE = 0x7C8 +- SYS_TOWCTRAN = 0x7D8 +- SYS_TOWCTRANS = 0x7D8 +- SYS_UNATEXIT = 0x7B5 +- SYS_VFWPRINT = 0x7D3 +- SYS_VFWPRINTF = 0x7D3 +- SYS_VWPRINTF = 0x7D4 +- SYS_WCTRANS = 0x7D7 +- SYS_WPRINTF = 0x7D2 +- SYS_WSCANF = 0x7D6 +- SYS___ASCTIME_R_A = 0x7A1 +- SYS___BASENAME_A = 0x7DC +- SYS___BTOWC_A = 0x7E4 +- SYS___CDUMP_A = 0x7B7 +- SYS___CEE3DMP_A = 0x7B6 +- SYS___CEILF_H = 0x7F4 +- SYS___CEILL_H = 0x7F5 +- SYS___CEIL_H = 0x7EA +- SYS___CRYPT_A = 0x7BE +- SYS___CSNAP_A = 0x7B8 +- SYS___CTEST_A = 0x7B9 +- SYS___CTIME_R_A = 0x7A2 +- SYS___CTRACE_A = 0x7BA +- SYS___DBM_OPEN_A = 0x7E6 +- SYS___DIRNAME_A = 0x7DD +- SYS___FABSF_H = 0x7FA +- SYS___FABSL_H = 0x7FB +- SYS___FABS_H = 0x7ED +- SYS___FGETWC_A = 0x7AA +- SYS___FGETWS_A = 0x7AD +- SYS___FLOORF_H = 0x7F6 +- SYS___FLOORL_H = 0x7F7 +- SYS___FLOOR_H = 0x7EB +- SYS___FPUTWC_A = 0x7A5 +- SYS___FPUTWS_A = 0x7A8 +- SYS___GETTIMEOFDAY_A = 0x7AE +- SYS___GETWCHAR_A = 0x7AC +- SYS___GETWC_A = 0x7AB +- SYS___GLOB_A = 0x7DE +- SYS___GMTIME_A = 0x7AF +- SYS___GMTIME_R_A = 0x7B0 +- SYS___INET_PTON_A = 0x7BC +- SYS___J0_H = 0x7EE +- SYS___J1_H = 0x7EF +- SYS___JN_H = 0x7F0 +- SYS___LOCALTIME_A = 0x7B1 +- SYS___LOCALTIME_R_A = 0x7B2 +- SYS___MALLOC24 = 0x7FC +- SYS___MALLOC31 = 0x7FD +- SYS___MKTIME_A = 0x7B3 +- SYS___MODFF_H = 0x7F8 +- SYS___MODFL_H = 0x7F9 +- SYS___MODF_H = 0x7EC +- SYS___OPENDIR_A = 0x7C2 +- SYS___OSNAME = 0x7E0 +- SYS___PUTWCHAR_A = 0x7A7 +- SYS___PUTWC_A = 0x7A6 +- SYS___READDIR_A = 0x7C3 +- SYS___STRTOLL_A = 0x7A3 +- SYS___STRTOULL_A = 0x7A4 +- SYS___SYSLOG_A = 0x7BD +- SYS___TZZNA = 0x7B4 +- SYS___UNGETWC_A = 0x7A9 +- SYS___UTIME_A = 0x7A0 +- SYS___VFPRINTF2_A = 0x7E7 +- SYS___VPRINTF2_A = 0x7E8 +- SYS___VSPRINTF2_A = 0x7E9 +- SYS___VSWPRNTF2_A = 0x7BB +- SYS___WCSTOD_A = 0x7D9 +- SYS___WCSTOL_A = 0x7DA +- SYS___WCSTOUL_A = 0x7DB +- SYS___WCTOB_A = 0x7E5 +- SYS___Y0_H = 0x7F1 +- SYS___Y1_H = 0x7F2 +- SYS___YN_H = 0x7F3 +- SYS_____OPENDIR2_A = 0x7BF +- SYS_____OSNAME_A = 0x7E1 +- SYS_____READDIR2_A = 0x7C0 +- SYS_DLCLOSE = 0x8DF +- SYS_DLERROR = 0x8E0 +- SYS_DLOPEN = 0x8DD +- SYS_DLSYM = 0x8DE +- SYS_FLOCKFILE = 0x8D3 +- SYS_FTRYLOCKFILE = 0x8D4 +- SYS_FUNLOCKFILE = 0x8D5 +- SYS_GETCHAR_UNLOCKED = 0x8D7 +- SYS_GETC_UNLOCKED = 0x8D6 +- SYS_PUTCHAR_UNLOCKED = 0x8D9 +- SYS_PUTC_UNLOCKED = 0x8D8 +- SYS_SNPRINTF = 0x8DA +- SYS_VSNPRINTF = 0x8DB +- SYS_WCSCSPN = 0x08B +- SYS_WCSLEN = 0x08C +- SYS_WCSNCAT = 0x08D +- SYS_WCSNCMP = 0x08A +- SYS_WCSNCPY = 0x08F +- SYS_WCSSPN = 0x08E +- SYS___ABSF_H = 0x8E7 +- SYS___ABSL_H = 0x8E8 +- SYS___ABS_H = 0x8E6 +- SYS___ACOSF_H = 0x8EA +- SYS___ACOSH_H = 0x8EC +- SYS___ACOSL_H = 0x8EB +- SYS___ACOS_H = 0x8E9 +- SYS___ASINF_H = 0x8EE +- SYS___ASINH_H = 0x8F0 +- SYS___ASINL_H = 0x8EF +- SYS___ASIN_H = 0x8ED +- SYS___ATAN2F_H = 0x8F8 +- SYS___ATAN2L_H = 0x8F9 +- SYS___ATAN2_H = 0x8F7 +- SYS___ATANF_H = 0x8F2 +- SYS___ATANHF_H = 0x8F5 +- SYS___ATANHL_H = 0x8F6 +- SYS___ATANH_H = 0x8F4 +- SYS___ATANL_H = 0x8F3 +- SYS___ATAN_H = 0x8F1 +- SYS___CBRT_H = 0x8FA +- SYS___COPYSIGNF_H = 0x8FB +- SYS___COPYSIGNL_H = 0x8FC +- SYS___COSF_H = 0x8FE +- SYS___COSL_H = 0x8FF +- SYS___COS_H = 0x8FD +- SYS___DLERROR_A = 0x8D2 +- SYS___DLOPEN_A = 0x8D0 +- SYS___DLSYM_A = 0x8D1 +- SYS___GETUTXENT_A = 0x8C6 +- SYS___GETUTXID_A = 0x8C7 +- SYS___GETUTXLINE_A = 0x8C8 +- SYS___ITOA = 0x8AA +- SYS___ITOA_A = 0x8B0 +- SYS___LE_CONDITION_TOKEN_BUILD = 0x8A5 +- SYS___LE_MSG_ADD_INSERT = 0x8A6 +- SYS___LE_MSG_GET = 0x8A7 +- SYS___LE_MSG_GET_AND_WRITE = 0x8A8 +- SYS___LE_MSG_WRITE = 0x8A9 +- SYS___LLTOA = 0x8AE +- SYS___LLTOA_A = 0x8B4 +- SYS___LTOA = 0x8AC +- SYS___LTOA_A = 0x8B2 +- SYS___PUTCHAR_UNLOCKED_A = 0x8CC +- SYS___PUTC_UNLOCKED_A = 0x8CB +- SYS___PUTUTXLINE_A = 0x8C9 +- SYS___RESET_EXCEPTION_HANDLER = 0x8E3 +- SYS___REXEC_A = 0x8C4 +- SYS___REXEC_AF_A = 0x8C5 +- SYS___SET_EXCEPTION_HANDLER = 0x8E2 +- SYS___SNPRINTF_A = 0x8CD +- SYS___SUPERKILL = 0x8A4 +- SYS___TCGETATTR_A = 0x8A1 +- SYS___TCSETATTR_A = 0x8A2 +- SYS___ULLTOA = 0x8AF +- SYS___ULLTOA_A = 0x8B5 +- SYS___ULTOA = 0x8AD +- SYS___ULTOA_A = 0x8B3 +- SYS___UTOA = 0x8AB +- SYS___UTOA_A = 0x8B1 +- SYS___VHM_EVENT = 0x8E4 +- SYS___VSNPRINTF_A = 0x8CE +- SYS_____GETENV_A = 0x8C3 +- SYS_____UTMPXNAME_A = 0x8CA +- SYS_CACOSH = 0x9A0 +- SYS_CACOSHF = 0x9A3 +- SYS_CACOSHL = 0x9A6 +- SYS_CARG = 0x9A9 +- SYS_CARGF = 0x9AC +- SYS_CARGL = 0x9AF +- SYS_CASIN = 0x9B2 +- SYS_CASINF = 0x9B5 +- SYS_CASINH = 0x9BB +- SYS_CASINHF = 0x9BE +- SYS_CASINHL = 0x9C1 +- SYS_CASINL = 0x9B8 +- SYS_CATAN = 0x9C4 +- SYS_CATANF = 0x9C7 +- SYS_CATANH = 0x9CD +- SYS_CATANHF = 0x9D0 +- SYS_CATANHL = 0x9D3 +- SYS_CATANL = 0x9CA +- SYS_CCOS = 0x9D6 +- SYS_CCOSF = 0x9D9 +- SYS_CCOSH = 0x9DF +- SYS_CCOSHF = 0x9E2 +- SYS_CCOSHL = 0x9E5 +- SYS_CCOSL = 0x9DC +- SYS_CEXP = 0x9E8 +- SYS_CEXPF = 0x9EB +- SYS_CEXPL = 0x9EE +- SYS_CIMAG = 0x9F1 +- SYS_CIMAGF = 0x9F4 +- SYS_CIMAGL = 0x9F7 +- SYS_CLOGF = 0x9FD +- SYS_MEMCHR = 0x09B +- SYS_MEMCMP = 0x09A +- SYS_STRCOLL = 0x09C +- SYS_STRNCMP = 0x09D +- SYS_STRRCHR = 0x09F +- SYS_STRXFRM = 0x09E +- SYS___CACOSHF_B = 0x9A4 +- SYS___CACOSHF_H = 0x9A5 +- SYS___CACOSHL_B = 0x9A7 +- SYS___CACOSHL_H = 0x9A8 +- SYS___CACOSH_B = 0x9A1 +- SYS___CACOSH_H = 0x9A2 +- SYS___CARGF_B = 0x9AD +- SYS___CARGF_H = 0x9AE +- SYS___CARGL_B = 0x9B0 +- SYS___CARGL_H = 0x9B1 +- SYS___CARG_B = 0x9AA +- SYS___CARG_H = 0x9AB +- SYS___CASINF_B = 0x9B6 +- SYS___CASINF_H = 0x9B7 +- SYS___CASINHF_B = 0x9BF +- SYS___CASINHF_H = 0x9C0 +- SYS___CASINHL_B = 0x9C2 +- SYS___CASINHL_H = 0x9C3 +- SYS___CASINH_B = 0x9BC +- SYS___CASINH_H = 0x9BD +- SYS___CASINL_B = 0x9B9 +- SYS___CASINL_H = 0x9BA +- SYS___CASIN_B = 0x9B3 +- SYS___CASIN_H = 0x9B4 +- SYS___CATANF_B = 0x9C8 +- SYS___CATANF_H = 0x9C9 +- SYS___CATANHF_B = 0x9D1 +- SYS___CATANHF_H = 0x9D2 +- SYS___CATANHL_B = 0x9D4 +- SYS___CATANHL_H = 0x9D5 +- SYS___CATANH_B = 0x9CE +- SYS___CATANH_H = 0x9CF +- SYS___CATANL_B = 0x9CB +- SYS___CATANL_H = 0x9CC +- SYS___CATAN_B = 0x9C5 +- SYS___CATAN_H = 0x9C6 +- SYS___CCOSF_B = 0x9DA +- SYS___CCOSF_H = 0x9DB +- SYS___CCOSHF_B = 0x9E3 +- SYS___CCOSHF_H = 0x9E4 +- SYS___CCOSHL_B = 0x9E6 +- SYS___CCOSHL_H = 0x9E7 +- SYS___CCOSH_B = 0x9E0 +- SYS___CCOSH_H = 0x9E1 +- SYS___CCOSL_B = 0x9DD +- SYS___CCOSL_H = 0x9DE +- SYS___CCOS_B = 0x9D7 +- SYS___CCOS_H = 0x9D8 +- SYS___CEXPF_B = 0x9EC +- SYS___CEXPF_H = 0x9ED +- SYS___CEXPL_B = 0x9EF +- SYS___CEXPL_H = 0x9F0 +- SYS___CEXP_B = 0x9E9 +- SYS___CEXP_H = 0x9EA +- SYS___CIMAGF_B = 0x9F5 +- SYS___CIMAGF_H = 0x9F6 +- SYS___CIMAGL_B = 0x9F8 +- SYS___CIMAGL_H = 0x9F9 +- SYS___CIMAG_B = 0x9F2 +- SYS___CIMAG_H = 0x9F3 +- SYS___CLOG = 0x9FA +- SYS___CLOGF_B = 0x9FE +- SYS___CLOGF_H = 0x9FF +- SYS___CLOG_B = 0x9FB +- SYS___CLOG_H = 0x9FC +- SYS_ISWCTYPE = 0x10C +- SYS_ISWXDIGI = 0x10A +- SYS_ISWXDIGIT = 0x10A +- SYS_MBSINIT = 0x10F +- SYS_TOWLOWER = 0x10D +- SYS_TOWUPPER = 0x10E +- SYS_WCTYPE = 0x10B +- SYS_WCSSTR = 0x11B +- SYS___RPMTCH = 0x11A +- SYS_WCSTOD = 0x12E +- SYS_WCSTOK = 0x12C +- SYS_WCSTOL = 0x12D +- SYS_WCSTOUL = 0x12F +- SYS_FGETWC = 0x13C +- SYS_FGETWS = 0x13D +- SYS_FPUTWC = 0x13E +- SYS_FPUTWS = 0x13F +- SYS_REGERROR = 0x13B +- SYS_REGFREE = 0x13A +- SYS_COLLEQUIV = 0x14F +- SYS_COLLTOSTR = 0x14E +- SYS_ISMCCOLLEL = 0x14C +- SYS_STRTOCOLL = 0x14D +- SYS_DLLFREE = 0x16F +- SYS_DLLQUERYFN = 0x16D +- SYS_DLLQUERYVAR = 0x16E +- SYS_GETMCCOLL = 0x16A +- SYS_GETWMCCOLL = 0x16B +- SYS___ERR2AD = 0x16C +- SYS_CFSETOSPEED = 0x17A +- SYS_CHDIR = 0x17B +- SYS_CHMOD = 0x17C +- SYS_CHOWN = 0x17D +- SYS_CLOSE = 0x17E +- SYS_CLOSEDIR = 0x17F +- SYS_LOG = 0x017 +- SYS_COSH = 0x018 +- SYS_FCHMOD = 0x18A +- SYS_FCHOWN = 0x18B +- SYS_FCNTL = 0x18C +- SYS_FILENO = 0x18D +- SYS_FORK = 0x18E +- SYS_FPATHCONF = 0x18F +- SYS_GETLOGIN = 0x19A +- SYS_GETPGRP = 0x19C +- SYS_GETPID = 0x19D +- SYS_GETPPID = 0x19E +- SYS_GETPWNAM = 0x19F +- SYS_TANH = 0x019 +- SYS_W_GETMNTENT = 0x19B +- SYS_POW = 0x020 +- SYS_PTHREAD_SELF = 0x20A +- SYS_PTHREAD_SETINTR = 0x20B +- SYS_PTHREAD_SETINTRTYPE = 0x20C +- SYS_PTHREAD_SETSPECIFIC = 0x20D +- SYS_PTHREAD_TESTINTR = 0x20E +- SYS_PTHREAD_YIELD = 0x20F +- SYS_SQRT = 0x021 +- SYS_FLOOR = 0x022 +- SYS_J1 = 0x023 +- SYS_WCSPBRK = 0x23F +- SYS_BSEARCH = 0x24C +- SYS_FABS = 0x024 +- SYS_GETENV = 0x24A +- SYS_LDIV = 0x24D +- SYS_SYSTEM = 0x24B +- SYS_FMOD = 0x025 +- SYS___RETHROW = 0x25F +- SYS___THROW = 0x25E +- SYS_J0 = 0x026 +- SYS_PUTENV = 0x26A +- SYS___GETENV = 0x26F +- SYS_SEMCTL = 0x27A +- SYS_SEMGET = 0x27B +- SYS_SEMOP = 0x27C +- SYS_SHMAT = 0x27D +- SYS_SHMCTL = 0x27E +- SYS_SHMDT = 0x27F +- SYS_YN = 0x027 +- SYS_JN = 0x028 +- SYS_SIGALTSTACK = 0x28A +- SYS_SIGHOLD = 0x28B +- SYS_SIGIGNORE = 0x28C +- SYS_SIGINTERRUPT = 0x28D +- SYS_SIGPAUSE = 0x28E +- SYS_SIGRELSE = 0x28F +- SYS_GETOPT = 0x29A +- SYS_GETSUBOPT = 0x29D +- SYS_LCHOWN = 0x29B +- SYS_SETPGRP = 0x29E +- SYS_TRUNCATE = 0x29C +- SYS_Y0 = 0x029 +- SYS___GDERR = 0x29F +- SYS_ISALPHA = 0x030 +- SYS_VFORK = 0x30F +- SYS__LONGJMP = 0x30D +- SYS__SETJMP = 0x30E +- SYS_GLOB = 0x31A +- SYS_GLOBFREE = 0x31B +- SYS_ISALNUM = 0x031 +- SYS_PUTW = 0x31C +- SYS_SEEKDIR = 0x31D +- SYS_TELLDIR = 0x31E +- SYS_TEMPNAM = 0x31F +- SYS_GETTIMEOFDAY_R = 0x32E +- SYS_ISLOWER = 0x032 +- SYS_LGAMMA = 0x32C +- SYS_REMAINDER = 0x32A +- SYS_SCALB = 0x32B +- SYS_SYNC = 0x32F +- SYS_TTYSLOT = 0x32D +- SYS_ENDPROTOENT = 0x33A +- SYS_ENDSERVENT = 0x33B +- SYS_GETHOSTBYADDR = 0x33D +- SYS_GETHOSTBYADDR_R = 0x33C +- SYS_GETHOSTBYNAME = 0x33F +- SYS_GETHOSTBYNAME_R = 0x33E +- SYS_ISCNTRL = 0x033 +- SYS_GETSERVBYNAME = 0x34A +- SYS_GETSERVBYPORT = 0x34B +- SYS_GETSERVENT = 0x34C +- SYS_GETSOCKNAME = 0x34D +- SYS_GETSOCKOPT = 0x34E +- SYS_INET_ADDR = 0x34F +- SYS_ISDIGIT = 0x034 +- SYS_ISGRAPH = 0x035 +- SYS_SELECT = 0x35B +- SYS_SELECTEX = 0x35C +- SYS_SEND = 0x35D +- SYS_SENDTO = 0x35F +- SYS_CHROOT = 0x36A +- SYS_ISNAN = 0x36D +- SYS_ISUPPER = 0x036 +- SYS_ULIMIT = 0x36C +- SYS_UTIMES = 0x36E +- SYS_W_STATVFS = 0x36B +- SYS___H_ERRNO = 0x36F +- SYS_GRANTPT = 0x37A +- SYS_ISPRINT = 0x037 +- SYS_TCGETSID = 0x37C +- SYS_UNLOCKPT = 0x37B +- SYS___TCGETCP = 0x37D +- SYS___TCSETCP = 0x37E +- SYS___TCSETTABLES = 0x37F +- SYS_ISPUNCT = 0x038 +- SYS_NLIST = 0x38C +- SYS___IPDBCS = 0x38D +- SYS___IPDSPX = 0x38E +- SYS___IPMSGC = 0x38F +- SYS___STHOSTENT = 0x38B +- SYS___STSERVENT = 0x38A +- SYS_ISSPACE = 0x039 +- SYS_COS = 0x040 +- SYS_T_ALLOC = 0x40A +- SYS_T_BIND = 0x40B +- SYS_T_CLOSE = 0x40C +- SYS_T_CONNECT = 0x40D +- SYS_T_ERROR = 0x40E +- SYS_T_FREE = 0x40F +- SYS_TAN = 0x041 +- SYS_T_RCVREL = 0x41A +- SYS_T_RCVUDATA = 0x41B +- SYS_T_RCVUDERR = 0x41C +- SYS_T_SND = 0x41D +- SYS_T_SNDDIS = 0x41E +- SYS_T_SNDREL = 0x41F +- SYS_GETPMSG = 0x42A +- SYS_ISASTREAM = 0x42B +- SYS_PUTMSG = 0x42C +- SYS_PUTPMSG = 0x42D +- SYS_SINH = 0x042 +- SYS___ISPOSIXON = 0x42E +- SYS___OPENMVSREL = 0x42F +- SYS_ACOS = 0x043 +- SYS_ATAN = 0x044 +- SYS_ATAN2 = 0x045 +- SYS_FTELL = 0x046 +- SYS_FGETPOS = 0x047 +- SYS_SOCK_DEBUG = 0x47A +- SYS_SOCK_DO_TESTSTOR = 0x47D +- SYS_TAKESOCKET = 0x47E +- SYS___SERVER_INIT = 0x47F +- SYS_FSEEK = 0x048 +- SYS___IPHOST = 0x48B +- SYS___IPNODE = 0x48C +- SYS___SERVER_CLASSIFY_CREATE = 0x48D +- SYS___SERVER_CLASSIFY_DESTROY = 0x48E +- SYS___SERVER_CLASSIFY_RESET = 0x48F +- SYS___SMF_RECORD = 0x48A +- SYS_FSETPOS = 0x049 +- SYS___FNWSA = 0x49B +- SYS___SPAWN2 = 0x49D +- SYS___SPAWNP2 = 0x49E +- SYS_ATOF = 0x050 +- SYS_PTHREAD_MUTEXATTR_GETPSHARED = 0x50A +- SYS_PTHREAD_MUTEXATTR_SETPSHARED = 0x50B +- SYS_PTHREAD_RWLOCK_DESTROY = 0x50C +- SYS_PTHREAD_RWLOCK_INIT = 0x50D +- SYS_PTHREAD_RWLOCK_RDLOCK = 0x50E +- SYS_PTHREAD_RWLOCK_TRYRDLOCK = 0x50F +- SYS_ATOI = 0x051 +- SYS___FP_CLASS = 0x51D +- SYS___FP_CLR_FLAG = 0x51A +- SYS___FP_FINITE = 0x51E +- SYS___FP_ISNAN = 0x51F +- SYS___FP_RAISE_XCP = 0x51C +- SYS___FP_READ_FLAG = 0x51B +- SYS_RAND = 0x052 +- SYS_SIGTIMEDWAIT = 0x52D +- SYS_SIGWAITINFO = 0x52E +- SYS___CHKBFP = 0x52F +- SYS___FPC_RS = 0x52C +- SYS___FPC_RW = 0x52A +- SYS___FPC_SM = 0x52B +- SYS_STRTOD = 0x053 +- SYS_STRTOL = 0x054 +- SYS_STRTOUL = 0x055 +- SYS_MALLOC = 0x056 +- SYS_SRAND = 0x057 +- SYS_CALLOC = 0x058 +- SYS_FREE = 0x059 +- SYS___OSENV = 0x59F +- SYS___W_PIOCTL = 0x59E +- SYS_LONGJMP = 0x060 +- SYS___FLOORF_B = 0x60A +- SYS___FLOORL_B = 0x60B +- SYS___FREXPF_B = 0x60C +- SYS___FREXPL_B = 0x60D +- SYS___LDEXPF_B = 0x60E +- SYS___LDEXPL_B = 0x60F +- SYS_SIGNAL = 0x061 +- SYS___ATAN2F_B = 0x61A +- SYS___ATAN2L_B = 0x61B +- SYS___COSHF_B = 0x61C +- SYS___COSHL_B = 0x61D +- SYS___EXPF_B = 0x61E +- SYS___EXPL_B = 0x61F +- SYS_TMPNAM = 0x062 +- SYS___ABSF_B = 0x62A +- SYS___ABSL_B = 0x62C +- SYS___ABS_B = 0x62B +- SYS___FMODF_B = 0x62D +- SYS___FMODL_B = 0x62E +- SYS___MODFF_B = 0x62F +- SYS_ATANL = 0x63A +- SYS_CEILF = 0x63B +- SYS_CEILL = 0x63C +- SYS_COSF = 0x63D +- SYS_COSHF = 0x63F +- SYS_COSL = 0x63E +- SYS_REMOVE = 0x063 +- SYS_POWL = 0x64A +- SYS_RENAME = 0x064 +- SYS_SINF = 0x64B +- SYS_SINHF = 0x64F +- SYS_SINL = 0x64C +- SYS_SQRTF = 0x64D +- SYS_SQRTL = 0x64E +- SYS_BTOWC = 0x65F +- SYS_FREXPL = 0x65A +- SYS_LDEXPF = 0x65B +- SYS_LDEXPL = 0x65C +- SYS_MODFF = 0x65D +- SYS_MODFL = 0x65E +- SYS_TMPFILE = 0x065 +- SYS_FREOPEN = 0x066 +- SYS___CHARMAP_INIT_A = 0x66E +- SYS___GETHOSTBYADDR_R_A = 0x66C +- SYS___GETHOSTBYNAME_A = 0x66A +- SYS___GETHOSTBYNAME_R_A = 0x66D +- SYS___MBLEN_A = 0x66F +- SYS___RES_INIT_A = 0x66B +- SYS_FCLOSE = 0x067 +- SYS___GETGRGID_R_A = 0x67D +- SYS___WCSTOMBS_A = 0x67A +- SYS___WCSTOMBS_STD_A = 0x67B +- SYS___WCSWIDTH_A = 0x67C +- SYS___WCSWIDTH_ASIA = 0x67F +- SYS___WCSWIDTH_STD_A = 0x67E +- SYS_FFLUSH = 0x068 +- SYS___GETLOGIN_R_A = 0x68E +- SYS___GETPWNAM_R_A = 0x68C +- SYS___GETPWUID_R_A = 0x68D +- SYS___TTYNAME_R_A = 0x68F +- SYS___WCWIDTH_ASIA = 0x68B +- SYS___WCWIDTH_STD_A = 0x68A +- SYS_FOPEN = 0x069 +- SYS___REGEXEC_A = 0x69A +- SYS___REGEXEC_STD_A = 0x69B +- SYS___REGFREE_A = 0x69C +- SYS___REGFREE_STD_A = 0x69D +- SYS___STRCOLL_A = 0x69E +- SYS___STRCOLL_C_A = 0x69F +- SYS_SCANF = 0x070 +- SYS___A64L_A = 0x70C +- SYS___ECVT_A = 0x70D +- SYS___FCVT_A = 0x70E +- SYS___GCVT_A = 0x70F +- SYS___STRTOUL_A = 0x70A +- SYS_____AE_CORRESTBL_QUERY_A = 0x70B +- SYS_SPRINTF = 0x071 +- SYS___ACCESS_A = 0x71F +- SYS___CATOPEN_A = 0x71E +- SYS___GETOPT_A = 0x71D +- SYS___REALPATH_A = 0x71A +- SYS___SETENV_A = 0x71B +- SYS___SYSTEM_A = 0x71C +- SYS_FGETC = 0x072 +- SYS___GAI_STRERROR_A = 0x72F +- SYS___RMDIR_A = 0x72A +- SYS___STATVFS_A = 0x72B +- SYS___SYMLINK_A = 0x72C +- SYS___TRUNCATE_A = 0x72D +- SYS___UNLINK_A = 0x72E +- SYS_VFPRINTF = 0x073 +- SYS___ISSPACE_A = 0x73A +- SYS___ISUPPER_A = 0x73B +- SYS___ISWALNUM_A = 0x73F +- SYS___ISXDIGIT_A = 0x73C +- SYS___TOLOWER_A = 0x73D +- SYS___TOUPPER_A = 0x73E +- SYS_VPRINTF = 0x074 +- SYS___CONFSTR_A = 0x74B +- SYS___FDOPEN_A = 0x74E +- SYS___FLDATA_A = 0x74F +- SYS___FTOK_A = 0x74C +- SYS___ISWXDIGIT_A = 0x74A +- SYS___MKTEMP_A = 0x74D +- SYS_VSPRINTF = 0x075 +- SYS___GETGRGID_A = 0x75A +- SYS___GETGRNAM_A = 0x75B +- SYS___GETGROUPSBYNAME_A = 0x75C +- SYS___GETHOSTENT_A = 0x75D +- SYS___GETHOSTNAME_A = 0x75E +- SYS___GETLOGIN_A = 0x75F +- SYS_GETC = 0x076 +- SYS___CREATEWORKUNIT_A = 0x76A +- SYS___CTERMID_A = 0x76B +- SYS___FMTMSG_A = 0x76C +- SYS___INITGROUPS_A = 0x76D +- SYS___MSGRCV_A = 0x76F +- SYS_____LOGIN_A = 0x76E +- SYS_FGETS = 0x077 +- SYS___STRCASECMP_A = 0x77B +- SYS___STRNCASECMP_A = 0x77C +- SYS___TTYNAME_A = 0x77D +- SYS___UNAME_A = 0x77E +- SYS___UTIMES_A = 0x77F +- SYS_____SERVER_PWU_A = 0x77A +- SYS_FPUTC = 0x078 +- SYS___CREAT_O_A = 0x78E +- SYS___ENVNA = 0x78F +- SYS___FREAD_A = 0x78A +- SYS___FWRITE_A = 0x78B +- SYS___ISASCII = 0x78D +- SYS___OPEN_O_A = 0x78C +- SYS_FPUTS = 0x079 +- SYS___ASCTIME_A = 0x79C +- SYS___CTIME_A = 0x79D +- SYS___GETDATE_A = 0x79E +- SYS___GETSERVBYPORT_A = 0x79A +- SYS___GETSERVENT_A = 0x79B +- SYS___TZSET_A = 0x79F +- SYS_ACL_FROM_TEXT = 0x80C +- SYS_ACL_SET_FD = 0x80A +- SYS_ACL_SET_FILE = 0x80B +- SYS_ACL_SORT = 0x80E +- SYS_ACL_TO_TEXT = 0x80D +- SYS_UNGETC = 0x080 +- SYS___SHUTDOWN_REGISTRATION = 0x80F +- SYS_FREAD = 0x081 +- SYS_FREEADDRINFO = 0x81A +- SYS_GAI_STRERROR = 0x81B +- SYS_REXEC_AF = 0x81C +- SYS___DYNALLOC_A = 0x81F +- SYS___POE = 0x81D +- SYS_WCSTOMBS = 0x082 +- SYS___INET_ADDR_A = 0x82F +- SYS___NLIST_A = 0x82A +- SYS_____TCGETCP_A = 0x82B +- SYS_____TCSETCP_A = 0x82C +- SYS_____W_PIOCTL_A = 0x82E +- SYS_MBTOWC = 0x083 +- SYS___CABEND = 0x83D +- SYS___LE_CIB_GET = 0x83E +- SYS___RECVMSG_A = 0x83B +- SYS___SENDMSG_A = 0x83A +- SYS___SET_LAA_FOR_JIT = 0x83F +- SYS_____LCHATTR_A = 0x83C +- SYS_WCTOMB = 0x084 +- SYS___CBRTL_B = 0x84A +- SYS___COPYSIGNF_B = 0x84B +- SYS___COPYSIGNL_B = 0x84C +- SYS___COTANF_B = 0x84D +- SYS___COTANL_B = 0x84F +- SYS___COTAN_B = 0x84E +- SYS_MBSTOWCS = 0x085 +- SYS___LOG1PL_B = 0x85A +- SYS___LOG2F_B = 0x85B +- SYS___LOG2L_B = 0x85D +- SYS___LOG2_B = 0x85C +- SYS___REMAINDERF_B = 0x85E +- SYS___REMAINDERL_B = 0x85F +- SYS_ACOSHF = 0x86E +- SYS_ACOSHL = 0x86F +- SYS_WCSCPY = 0x086 +- SYS___ERFCF_B = 0x86D +- SYS___ERFF_B = 0x86C +- SYS___LROUNDF_B = 0x86A +- SYS___LROUND_B = 0x86B +- SYS_COTANL = 0x87A +- SYS_EXP2F = 0x87B +- SYS_EXP2L = 0x87C +- SYS_EXPM1F = 0x87D +- SYS_EXPM1L = 0x87E +- SYS_FDIMF = 0x87F +- SYS_WCSCAT = 0x087 +- SYS___COTANL = 0x87A +- SYS_REMAINDERF = 0x88A +- SYS_REMAINDERL = 0x88B +- SYS_REMAINDF = 0x88A +- SYS_REMAINDL = 0x88B +- SYS_REMQUO = 0x88D +- SYS_REMQUOF = 0x88C +- SYS_REMQUOL = 0x88E +- SYS_TGAMMAF = 0x88F +- SYS_WCSCHR = 0x088 +- SYS_ERFCF = 0x89B +- SYS_ERFCL = 0x89C +- SYS_ERFL = 0x89A +- SYS_EXP2 = 0x89E +- SYS_WCSCMP = 0x089 +- SYS___EXP2_B = 0x89D +- SYS___FAR_JUMP = 0x89F +- SYS_ABS = 0x090 +- SYS___ERFCL_H = 0x90A +- SYS___EXPF_H = 0x90C +- SYS___EXPL_H = 0x90D +- SYS___EXPM1_H = 0x90E +- SYS___EXP_H = 0x90B +- SYS___FDIM_H = 0x90F +- SYS_DIV = 0x091 +- SYS___LOG2F_H = 0x91F +- SYS___LOG2_H = 0x91E +- SYS___LOGB_H = 0x91D +- SYS___LOGF_H = 0x91B +- SYS___LOGL_H = 0x91C +- SYS___LOG_H = 0x91A +- SYS_LABS = 0x092 +- SYS___POWL_H = 0x92A +- SYS___REMAINDER_H = 0x92B +- SYS___RINT_H = 0x92C +- SYS___SCALB_H = 0x92D +- SYS___SINF_H = 0x92F +- SYS___SIN_H = 0x92E +- SYS_STRNCPY = 0x093 +- SYS___TANHF_H = 0x93B +- SYS___TANHL_H = 0x93C +- SYS___TANH_H = 0x93A +- SYS___TGAMMAF_H = 0x93E +- SYS___TGAMMA_H = 0x93D +- SYS___TRUNC_H = 0x93F +- SYS_MEMCPY = 0x094 +- SYS_VFWSCANF = 0x94A +- SYS_VSWSCANF = 0x94E +- SYS_VWSCANF = 0x94C +- SYS_INET6_RTH_ADD = 0x95D +- SYS_INET6_RTH_INIT = 0x95C +- SYS_INET6_RTH_REVERSE = 0x95E +- SYS_INET6_RTH_SEGMENTS = 0x95F +- SYS_INET6_RTH_SPACE = 0x95B +- SYS_MEMMOVE = 0x095 +- SYS_WCSTOLD = 0x95A +- SYS_STRCPY = 0x096 +- SYS_STRCMP = 0x097 +- SYS_CABS = 0x98E +- SYS_STRCAT = 0x098 +- SYS___CABS_B = 0x98F +- SYS___POW_II = 0x98A +- SYS___POW_II_B = 0x98B +- SYS___POW_II_H = 0x98C +- SYS_CACOSF = 0x99A +- SYS_CACOSL = 0x99D +- SYS_STRNCAT = 0x099 +- SYS___CACOSF_B = 0x99B +- SYS___CACOSF_H = 0x99C +- SYS___CACOSL_B = 0x99E +- SYS___CACOSL_H = 0x99F +- SYS_ISWALPHA = 0x100 +- SYS_ISWBLANK = 0x101 +- SYS___ISWBLK = 0x101 +- SYS_ISWCNTRL = 0x102 +- SYS_ISWDIGIT = 0x103 +- SYS_ISWGRAPH = 0x104 +- SYS_ISWLOWER = 0x105 +- SYS_ISWPRINT = 0x106 +- SYS_ISWPUNCT = 0x107 +- SYS_ISWSPACE = 0x108 +- SYS_ISWUPPER = 0x109 +- SYS_WCTOB = 0x110 +- SYS_MBRLEN = 0x111 +- SYS_MBRTOWC = 0x112 +- SYS_MBSRTOWC = 0x113 +- SYS_MBSRTOWCS = 0x113 +- SYS_WCRTOMB = 0x114 +- SYS_WCSRTOMB = 0x115 +- SYS_WCSRTOMBS = 0x115 +- SYS___CSID = 0x116 +- SYS___WCSID = 0x117 +- SYS_STRPTIME = 0x118 +- SYS___STRPTM = 0x118 +- SYS_STRFMON = 0x119 +- SYS_WCSCOLL = 0x130 +- SYS_WCSXFRM = 0x131 +- SYS_WCSWIDTH = 0x132 +- SYS_WCWIDTH = 0x133 +- SYS_WCSFTIME = 0x134 +- SYS_SWPRINTF = 0x135 +- SYS_VSWPRINT = 0x136 +- SYS_VSWPRINTF = 0x136 +- SYS_SWSCANF = 0x137 +- SYS_REGCOMP = 0x138 +- SYS_REGEXEC = 0x139 +- SYS_GETWC = 0x140 +- SYS_GETWCHAR = 0x141 +- SYS_PUTWC = 0x142 +- SYS_PUTWCHAR = 0x143 +- SYS_UNGETWC = 0x144 +- SYS_ICONV_OPEN = 0x145 +- SYS_ICONV = 0x146 +- SYS_ICONV_CLOSE = 0x147 +- SYS_COLLRANGE = 0x150 +- SYS_CCLASS = 0x151 +- SYS_COLLORDER = 0x152 +- SYS___DEMANGLE = 0x154 +- SYS_FDOPEN = 0x155 +- SYS___ERRNO = 0x156 +- SYS___ERRNO2 = 0x157 +- SYS___TERROR = 0x158 +- SYS_MAXCOLL = 0x169 +- SYS_DLLLOAD = 0x170 +- SYS__EXIT = 0x174 +- SYS_ACCESS = 0x175 +- SYS_ALARM = 0x176 +- SYS_CFGETISPEED = 0x177 +- SYS_CFGETOSPEED = 0x178 +- SYS_CFSETISPEED = 0x179 +- SYS_CREAT = 0x180 +- SYS_CTERMID = 0x181 +- SYS_DUP = 0x182 +- SYS_DUP2 = 0x183 +- SYS_EXECL = 0x184 +- SYS_EXECLE = 0x185 +- SYS_EXECLP = 0x186 +- SYS_EXECV = 0x187 +- SYS_EXECVE = 0x188 +- SYS_EXECVP = 0x189 +- SYS_FSTAT = 0x190 +- SYS_FSYNC = 0x191 +- SYS_FTRUNCATE = 0x192 +- SYS_GETCWD = 0x193 +- SYS_GETEGID = 0x194 +- SYS_GETEUID = 0x195 +- SYS_GETGID = 0x196 +- SYS_GETGRGID = 0x197 +- SYS_GETGRNAM = 0x198 +- SYS_GETGROUPS = 0x199 +- SYS_PTHREAD_MUTEXATTR_DESTROY = 0x200 +- SYS_PTHREAD_MUTEXATTR_SETKIND_NP = 0x201 +- SYS_PTHREAD_MUTEXATTR_GETKIND_NP = 0x202 +- SYS_PTHREAD_MUTEX_INIT = 0x203 +- SYS_PTHREAD_MUTEX_DESTROY = 0x204 +- SYS_PTHREAD_MUTEX_LOCK = 0x205 +- SYS_PTHREAD_MUTEX_TRYLOCK = 0x206 +- SYS_PTHREAD_MUTEX_UNLOCK = 0x207 +- SYS_PTHREAD_ONCE = 0x209 +- SYS_TW_OPEN = 0x210 +- SYS_TW_FCNTL = 0x211 +- SYS_PTHREAD_JOIN_D4_NP = 0x212 +- SYS_PTHREAD_CONDATTR_SETKIND_NP = 0x213 +- SYS_PTHREAD_CONDATTR_GETKIND_NP = 0x214 +- SYS_EXTLINK_NP = 0x215 +- SYS___PASSWD = 0x216 +- SYS_SETGROUPS = 0x217 +- SYS_INITGROUPS = 0x218 +- SYS_WCSRCHR = 0x240 +- SYS_SVC99 = 0x241 +- SYS___SVC99 = 0x241 +- SYS_WCSWCS = 0x242 +- SYS_LOCALECO = 0x243 +- SYS_LOCALECONV = 0x243 +- SYS___LIBREL = 0x244 +- SYS_RELEASE = 0x245 +- SYS___RLSE = 0x245 +- SYS_FLOCATE = 0x246 +- SYS___FLOCT = 0x246 +- SYS_FDELREC = 0x247 +- SYS___FDLREC = 0x247 +- SYS_FETCH = 0x248 +- SYS___FETCH = 0x248 +- SYS_QSORT = 0x249 +- SYS___CLEANUPCATCH = 0x260 +- SYS___CATCHMATCH = 0x261 +- SYS___CLEAN2UPCATCH = 0x262 +- SYS_GETPRIORITY = 0x270 +- SYS_NICE = 0x271 +- SYS_SETPRIORITY = 0x272 +- SYS_GETITIMER = 0x273 +- SYS_SETITIMER = 0x274 +- SYS_MSGCTL = 0x275 +- SYS_MSGGET = 0x276 +- SYS_MSGRCV = 0x277 +- SYS_MSGSND = 0x278 +- SYS_MSGXRCV = 0x279 +- SYS___MSGXR = 0x279 +- SYS_SHMGET = 0x280 +- SYS___GETIPC = 0x281 +- SYS_SETGRENT = 0x282 +- SYS_GETGRENT = 0x283 +- SYS_ENDGRENT = 0x284 +- SYS_SETPWENT = 0x285 +- SYS_GETPWENT = 0x286 +- SYS_ENDPWENT = 0x287 +- SYS_BSD_SIGNAL = 0x288 +- SYS_KILLPG = 0x289 +- SYS_SIGSET = 0x290 +- SYS_SIGSTACK = 0x291 +- SYS_GETRLIMIT = 0x292 +- SYS_SETRLIMIT = 0x293 +- SYS_GETRUSAGE = 0x294 +- SYS_MMAP = 0x295 +- SYS_MPROTECT = 0x296 +- SYS_MSYNC = 0x297 +- SYS_MUNMAP = 0x298 +- SYS_CONFSTR = 0x299 +- SYS___NDMTRM = 0x300 +- SYS_FTOK = 0x301 +- SYS_BASENAME = 0x302 +- SYS_DIRNAME = 0x303 +- SYS_GETDTABLESIZE = 0x304 +- SYS_MKSTEMP = 0x305 +- SYS_MKTEMP = 0x306 +- SYS_NFTW = 0x307 +- SYS_GETWD = 0x308 +- SYS_LOCKF = 0x309 +- SYS_WORDEXP = 0x310 +- SYS_WORDFREE = 0x311 +- SYS_GETPGID = 0x312 +- SYS_GETSID = 0x313 +- SYS___UTMPXNAME = 0x314 +- SYS_CUSERID = 0x315 +- SYS_GETPASS = 0x316 +- SYS_FNMATCH = 0x317 +- SYS_FTW = 0x318 +- SYS_GETW = 0x319 +- SYS_ACOSH = 0x320 +- SYS_ASINH = 0x321 +- SYS_ATANH = 0x322 +- SYS_CBRT = 0x323 +- SYS_EXPM1 = 0x324 +- SYS_ILOGB = 0x325 +- SYS_LOGB = 0x326 +- SYS_LOG1P = 0x327 +- SYS_NEXTAFTER = 0x328 +- SYS_RINT = 0x329 +- SYS_SPAWN = 0x330 +- SYS_SPAWNP = 0x331 +- SYS_GETLOGIN_UU = 0x332 +- SYS_ECVT = 0x333 +- SYS_FCVT = 0x334 +- SYS_GCVT = 0x335 +- SYS_ACCEPT = 0x336 +- SYS_BIND = 0x337 +- SYS_CONNECT = 0x338 +- SYS_ENDHOSTENT = 0x339 +- SYS_GETHOSTENT = 0x340 +- SYS_GETHOSTID = 0x341 +- SYS_GETHOSTNAME = 0x342 +- SYS_GETNETBYADDR = 0x343 +- SYS_GETNETBYNAME = 0x344 +- SYS_GETNETENT = 0x345 +- SYS_GETPEERNAME = 0x346 +- SYS_GETPROTOBYNAME = 0x347 +- SYS_GETPROTOBYNUMBER = 0x348 +- SYS_GETPROTOENT = 0x349 +- SYS_INET_LNAOF = 0x350 +- SYS_INET_MAKEADDR = 0x351 +- SYS_INET_NETOF = 0x352 +- SYS_INET_NETWORK = 0x353 +- SYS_INET_NTOA = 0x354 +- SYS_IOCTL = 0x355 +- SYS_LISTEN = 0x356 +- SYS_READV = 0x357 +- SYS_RECV = 0x358 +- SYS_RECVFROM = 0x359 +- SYS_SETHOSTENT = 0x360 +- SYS_SETNETENT = 0x361 +- SYS_SETPEER = 0x362 +- SYS_SETPROTOENT = 0x363 +- SYS_SETSERVENT = 0x364 +- SYS_SETSOCKOPT = 0x365 +- SYS_SHUTDOWN = 0x366 +- SYS_SOCKET = 0x367 +- SYS_SOCKETPAIR = 0x368 +- SYS_WRITEV = 0x369 +- SYS_ENDNETENT = 0x370 +- SYS_CLOSELOG = 0x371 +- SYS_OPENLOG = 0x372 +- SYS_SETLOGMASK = 0x373 +- SYS_SYSLOG = 0x374 +- SYS_PTSNAME = 0x375 +- SYS_SETREUID = 0x376 +- SYS_SETREGID = 0x377 +- SYS_REALPATH = 0x378 +- SYS___SIGNGAM = 0x379 +- SYS_POLL = 0x380 +- SYS_REXEC = 0x381 +- SYS___ISASCII2 = 0x382 +- SYS___TOASCII2 = 0x383 +- SYS_CHPRIORITY = 0x384 +- SYS_PTHREAD_ATTR_SETSYNCTYPE_NP = 0x385 +- SYS_PTHREAD_ATTR_GETSYNCTYPE_NP = 0x386 +- SYS_PTHREAD_SET_LIMIT_NP = 0x387 +- SYS___STNETENT = 0x388 +- SYS___STPROTOENT = 0x389 +- SYS___SELECT1 = 0x390 +- SYS_PTHREAD_SECURITY_NP = 0x391 +- SYS___CHECK_RESOURCE_AUTH_NP = 0x392 +- SYS___CONVERT_ID_NP = 0x393 +- SYS___OPENVMREL = 0x394 +- SYS_WMEMCHR = 0x395 +- SYS_WMEMCMP = 0x396 +- SYS_WMEMCPY = 0x397 +- SYS_WMEMMOVE = 0x398 +- SYS_WMEMSET = 0x399 +- SYS___FPUTWC = 0x400 +- SYS___PUTWC = 0x401 +- SYS___PWCHAR = 0x402 +- SYS___WCSFTM = 0x403 +- SYS___WCSTOK = 0x404 +- SYS___WCWDTH = 0x405 +- SYS_T_ACCEPT = 0x409 +- SYS_T_GETINFO = 0x410 +- SYS_T_GETPROTADDR = 0x411 +- SYS_T_GETSTATE = 0x412 +- SYS_T_LISTEN = 0x413 +- SYS_T_LOOK = 0x414 +- SYS_T_OPEN = 0x415 +- SYS_T_OPTMGMT = 0x416 +- SYS_T_RCV = 0x417 +- SYS_T_RCVCONNECT = 0x418 +- SYS_T_RCVDIS = 0x419 +- SYS_T_SNDUDATA = 0x420 +- SYS_T_STRERROR = 0x421 +- SYS_T_SYNC = 0x422 +- SYS_T_UNBIND = 0x423 +- SYS___T_ERRNO = 0x424 +- SYS___RECVMSG2 = 0x425 +- SYS___SENDMSG2 = 0x426 +- SYS_FATTACH = 0x427 +- SYS_FDETACH = 0x428 +- SYS_GETMSG = 0x429 +- SYS_GETCONTEXT = 0x430 +- SYS_SETCONTEXT = 0x431 +- SYS_MAKECONTEXT = 0x432 +- SYS_SWAPCONTEXT = 0x433 +- SYS_PTHREAD_GETSPECIFIC_D8_NP = 0x434 +- SYS_GETCLIENTID = 0x470 +- SYS___GETCLIENTID = 0x471 +- SYS_GETSTABLESIZE = 0x472 +- SYS_GETIBMOPT = 0x473 +- SYS_GETIBMSOCKOPT = 0x474 +- SYS_GIVESOCKET = 0x475 +- SYS_IBMSFLUSH = 0x476 +- SYS_MAXDESC = 0x477 +- SYS_SETIBMOPT = 0x478 +- SYS_SETIBMSOCKOPT = 0x479 +- SYS___SERVER_PWU = 0x480 +- SYS_PTHREAD_TAG_NP = 0x481 +- SYS___CONSOLE = 0x482 +- SYS___WSINIT = 0x483 +- SYS___IPTCPN = 0x489 +- SYS___SERVER_CLASSIFY = 0x490 +- SYS___HEAPRPT = 0x496 +- SYS___ISBFP = 0x500 +- SYS___FP_CAST = 0x501 +- SYS___CERTIFICATE = 0x502 +- SYS_SEND_FILE = 0x503 +- SYS_AIO_CANCEL = 0x504 +- SYS_AIO_ERROR = 0x505 +- SYS_AIO_READ = 0x506 +- SYS_AIO_RETURN = 0x507 +- SYS_AIO_SUSPEND = 0x508 +- SYS_AIO_WRITE = 0x509 +- SYS_PTHREAD_RWLOCK_TRYWRLOCK = 0x510 +- SYS_PTHREAD_RWLOCK_UNLOCK = 0x511 +- SYS_PTHREAD_RWLOCK_WRLOCK = 0x512 +- SYS_PTHREAD_RWLOCKATTR_GETPSHARED = 0x513 +- SYS_PTHREAD_RWLOCKATTR_SETPSHARED = 0x514 +- SYS_PTHREAD_RWLOCKATTR_INIT = 0x515 +- SYS_PTHREAD_RWLOCKATTR_DESTROY = 0x516 +- SYS___CTTBL = 0x517 +- SYS_PTHREAD_MUTEXATTR_SETTYPE = 0x518 +- SYS_PTHREAD_MUTEXATTR_GETTYPE = 0x519 +- SYS___FP_UNORDERED = 0x520 +- SYS___FP_READ_RND = 0x521 +- SYS___FP_READ_RND_B = 0x522 +- SYS___FP_SWAP_RND = 0x523 +- SYS___FP_SWAP_RND_B = 0x524 +- SYS___FP_LEVEL = 0x525 +- SYS___FP_BTOH = 0x526 +- SYS___FP_HTOB = 0x527 +- SYS___FPC_RD = 0x528 +- SYS___FPC_WR = 0x529 +- SYS_PTHREAD_SETCANCELTYPE = 0x600 +- SYS_PTHREAD_TESTCANCEL = 0x601 +- SYS___ATANF_B = 0x602 +- SYS___ATANL_B = 0x603 +- SYS___CEILF_B = 0x604 +- SYS___CEILL_B = 0x605 +- SYS___COSF_B = 0x606 +- SYS___COSL_B = 0x607 +- SYS___FABSF_B = 0x608 +- SYS___FABSL_B = 0x609 +- SYS___SINF_B = 0x610 +- SYS___SINL_B = 0x611 +- SYS___TANF_B = 0x612 +- SYS___TANL_B = 0x613 +- SYS___TANHF_B = 0x614 +- SYS___TANHL_B = 0x615 +- SYS___ACOSF_B = 0x616 +- SYS___ACOSL_B = 0x617 +- SYS___ASINF_B = 0x618 +- SYS___ASINL_B = 0x619 +- SYS___LOGF_B = 0x620 +- SYS___LOGL_B = 0x621 +- SYS___LOG10F_B = 0x622 +- SYS___LOG10L_B = 0x623 +- SYS___POWF_B = 0x624 +- SYS___POWL_B = 0x625 +- SYS___SINHF_B = 0x626 +- SYS___SINHL_B = 0x627 +- SYS___SQRTF_B = 0x628 +- SYS___SQRTL_B = 0x629 +- SYS___MODFL_B = 0x630 +- SYS_ABSF = 0x631 +- SYS_ABSL = 0x632 +- SYS_ACOSF = 0x633 +- SYS_ACOSL = 0x634 +- SYS_ASINF = 0x635 +- SYS_ASINL = 0x636 +- SYS_ATAN2F = 0x637 +- SYS_ATAN2L = 0x638 +- SYS_ATANF = 0x639 +- SYS_COSHL = 0x640 +- SYS_EXPF = 0x641 +- SYS_EXPL = 0x642 +- SYS_TANHF = 0x643 +- SYS_TANHL = 0x644 +- SYS_LOG10F = 0x645 +- SYS_LOG10L = 0x646 +- SYS_LOGF = 0x647 +- SYS_LOGL = 0x648 +- SYS_POWF = 0x649 +- SYS_SINHL = 0x650 +- SYS_TANF = 0x651 +- SYS_TANL = 0x652 +- SYS_FABSF = 0x653 +- SYS_FABSL = 0x654 +- SYS_FLOORF = 0x655 +- SYS_FLOORL = 0x656 +- SYS_FMODF = 0x657 +- SYS_FMODL = 0x658 +- SYS_FREXPF = 0x659 +- SYS___CHATTR = 0x660 +- SYS___FCHATTR = 0x661 +- SYS___TOCCSID = 0x662 +- SYS___CSNAMETYPE = 0x663 +- SYS___TOCSNAME = 0x664 +- SYS___CCSIDTYPE = 0x665 +- SYS___AE_CORRESTBL_QUERY = 0x666 +- SYS___AE_AUTOCONVERT_STATE = 0x667 +- SYS_DN_FIND = 0x668 +- SYS___GETHOSTBYADDR_A = 0x669 +- SYS___MBLEN_SB_A = 0x670 +- SYS___MBLEN_STD_A = 0x671 +- SYS___MBLEN_UTF = 0x672 +- SYS___MBSTOWCS_A = 0x673 +- SYS___MBSTOWCS_STD_A = 0x674 +- SYS___MBTOWC_A = 0x675 +- SYS___MBTOWC_ISO1 = 0x676 +- SYS___MBTOWC_SBCS = 0x677 +- SYS___MBTOWC_MBCS = 0x678 +- SYS___MBTOWC_UTF = 0x679 +- SYS___CSID_A = 0x680 +- SYS___CSID_STD_A = 0x681 +- SYS___WCSID_A = 0x682 +- SYS___WCSID_STD_A = 0x683 +- SYS___WCTOMB_A = 0x684 +- SYS___WCTOMB_ISO1 = 0x685 +- SYS___WCTOMB_STD_A = 0x686 +- SYS___WCTOMB_UTF = 0x687 +- SYS___WCWIDTH_A = 0x688 +- SYS___GETGRNAM_R_A = 0x689 +- SYS___READDIR_R_A = 0x690 +- SYS___E2A_S = 0x691 +- SYS___FNMATCH_A = 0x692 +- SYS___FNMATCH_C_A = 0x693 +- SYS___EXECL_A = 0x694 +- SYS___FNMATCH_STD_A = 0x695 +- SYS___REGCOMP_A = 0x696 +- SYS___REGCOMP_STD_A = 0x697 +- SYS___REGERROR_A = 0x698 +- SYS___REGERROR_STD_A = 0x699 +- SYS___SWPRINTF_A = 0x700 +- SYS___FSCANF_A = 0x701 +- SYS___SCANF_A = 0x702 +- SYS___SSCANF_A = 0x703 +- SYS___SWSCANF_A = 0x704 +- SYS___ATOF_A = 0x705 +- SYS___ATOI_A = 0x706 +- SYS___ATOL_A = 0x707 +- SYS___STRTOD_A = 0x708 +- SYS___STRTOL_A = 0x709 +- SYS___L64A_A = 0x710 +- SYS___STRERROR_A = 0x711 +- SYS___PERROR_A = 0x712 +- SYS___FETCH_A = 0x713 +- SYS___GETENV_A = 0x714 +- SYS___MKSTEMP_A = 0x717 +- SYS___PTSNAME_A = 0x718 +- SYS___PUTENV_A = 0x719 +- SYS___CHDIR_A = 0x720 +- SYS___CHOWN_A = 0x721 +- SYS___CHROOT_A = 0x722 +- SYS___GETCWD_A = 0x723 +- SYS___GETWD_A = 0x724 +- SYS___LCHOWN_A = 0x725 +- SYS___LINK_A = 0x726 +- SYS___PATHCONF_A = 0x727 +- SYS___IF_NAMEINDEX_A = 0x728 +- SYS___READLINK_A = 0x729 +- SYS___EXTLINK_NP_A = 0x730 +- SYS___ISALNUM_A = 0x731 +- SYS___ISALPHA_A = 0x732 +- SYS___A2E_S = 0x733 +- SYS___ISCNTRL_A = 0x734 +- SYS___ISDIGIT_A = 0x735 +- SYS___ISGRAPH_A = 0x736 +- SYS___ISLOWER_A = 0x737 +- SYS___ISPRINT_A = 0x738 +- SYS___ISPUNCT_A = 0x739 +- SYS___ISWALPHA_A = 0x740 +- SYS___A2E_L = 0x741 +- SYS___ISWCNTRL_A = 0x742 +- SYS___ISWDIGIT_A = 0x743 +- SYS___ISWGRAPH_A = 0x744 +- SYS___ISWLOWER_A = 0x745 +- SYS___ISWPRINT_A = 0x746 +- SYS___ISWPUNCT_A = 0x747 +- SYS___ISWSPACE_A = 0x748 +- SYS___ISWUPPER_A = 0x749 +- SYS___REMOVE_A = 0x750 +- SYS___RENAME_A = 0x751 +- SYS___TMPNAM_A = 0x752 +- SYS___FOPEN_A = 0x753 +- SYS___FREOPEN_A = 0x754 +- SYS___CUSERID_A = 0x755 +- SYS___POPEN_A = 0x756 +- SYS___TEMPNAM_A = 0x757 +- SYS___FTW_A = 0x758 +- SYS___GETGRENT_A = 0x759 +- SYS___INET_NTOP_A = 0x760 +- SYS___GETPASS_A = 0x761 +- SYS___GETPWENT_A = 0x762 +- SYS___GETPWNAM_A = 0x763 +- SYS___GETPWUID_A = 0x764 +- SYS_____CHECK_RESOURCE_AUTH_NP_A = 0x765 +- SYS___CHECKSCHENV_A = 0x766 +- SYS___CONNECTSERVER_A = 0x767 +- SYS___CONNECTWORKMGR_A = 0x768 +- SYS_____CONSOLE_A = 0x769 +- SYS___MSGSND_A = 0x770 +- SYS___MSGXRCV_A = 0x771 +- SYS___NFTW_A = 0x772 +- SYS_____PASSWD_A = 0x773 +- SYS___PTHREAD_SECURITY_NP_A = 0x774 +- SYS___QUERYMETRICS_A = 0x775 +- SYS___QUERYSCHENV = 0x776 +- SYS___READV_A = 0x777 +- SYS_____SERVER_CLASSIFY_A = 0x778 +- SYS_____SERVER_INIT_A = 0x779 +- SYS___W_GETPSENT_A = 0x780 +- SYS___WRITEV_A = 0x781 +- SYS___W_STATFS_A = 0x782 +- SYS___W_STATVFS_A = 0x783 +- SYS___FPUTC_A = 0x784 +- SYS___PUTCHAR_A = 0x785 +- SYS___PUTS_A = 0x786 +- SYS___FGETS_A = 0x787 +- SYS___GETS_A = 0x788 +- SYS___FPUTS_A = 0x789 +- SYS___PUTC_A = 0x790 +- SYS___AE_THREAD_SETMODE = 0x791 +- SYS___AE_THREAD_SWAPMODE = 0x792 +- SYS___GETNETBYADDR_A = 0x793 +- SYS___GETNETBYNAME_A = 0x794 +- SYS___GETNETENT_A = 0x795 +- SYS___GETPROTOBYNAME_A = 0x796 +- SYS___GETPROTOBYNUMBER_A = 0x797 +- SYS___GETPROTOENT_A = 0x798 +- SYS___GETSERVBYNAME_A = 0x799 +- SYS_ACL_FIRST_ENTRY = 0x800 +- SYS_ACL_GET_ENTRY = 0x801 +- SYS_ACL_VALID = 0x802 +- SYS_ACL_CREATE_ENTRY = 0x803 +- SYS_ACL_DELETE_ENTRY = 0x804 +- SYS_ACL_UPDATE_ENTRY = 0x805 +- SYS_ACL_DELETE_FD = 0x806 +- SYS_ACL_DELETE_FILE = 0x807 +- SYS_ACL_GET_FD = 0x808 +- SYS_ACL_GET_FILE = 0x809 +- SYS___ERFL_B = 0x810 +- SYS___ERFCL_B = 0x811 +- SYS___LGAMMAL_B = 0x812 +- SYS___SETHOOKEVENTS = 0x813 +- SYS_IF_NAMETOINDEX = 0x814 +- SYS_IF_INDEXTONAME = 0x815 +- SYS_IF_NAMEINDEX = 0x816 +- SYS_IF_FREENAMEINDEX = 0x817 +- SYS_GETADDRINFO = 0x818 +- SYS_GETNAMEINFO = 0x819 +- SYS___DYNFREE_A = 0x820 +- SYS___RES_QUERY_A = 0x821 +- SYS___RES_SEARCH_A = 0x822 +- SYS___RES_QUERYDOMAIN_A = 0x823 +- SYS___RES_MKQUERY_A = 0x824 +- SYS___RES_SEND_A = 0x825 +- SYS___DN_EXPAND_A = 0x826 +- SYS___DN_SKIPNAME_A = 0x827 +- SYS___DN_COMP_A = 0x828 +- SYS___DN_FIND_A = 0x829 +- SYS___INET_NTOA_A = 0x830 +- SYS___INET_NETWORK_A = 0x831 +- SYS___ACCEPT_A = 0x832 +- SYS___ACCEPT_AND_RECV_A = 0x833 +- SYS___BIND_A = 0x834 +- SYS___CONNECT_A = 0x835 +- SYS___GETPEERNAME_A = 0x836 +- SYS___GETSOCKNAME_A = 0x837 +- SYS___RECVFROM_A = 0x838 +- SYS___SENDTO_A = 0x839 +- SYS___LCHATTR = 0x840 +- SYS___WRITEDOWN = 0x841 +- SYS_PTHREAD_MUTEX_INIT2 = 0x842 +- SYS___ACOSHF_B = 0x843 +- SYS___ACOSHL_B = 0x844 +- SYS___ASINHF_B = 0x845 +- SYS___ASINHL_B = 0x846 +- SYS___ATANHF_B = 0x847 +- SYS___ATANHL_B = 0x848 +- SYS___CBRTF_B = 0x849 +- SYS___EXP2F_B = 0x850 +- SYS___EXP2L_B = 0x851 +- SYS___EXPM1F_B = 0x852 +- SYS___EXPM1L_B = 0x853 +- SYS___FDIMF_B = 0x854 +- SYS___FDIM_B = 0x855 +- SYS___FDIML_B = 0x856 +- SYS___HYPOTF_B = 0x857 +- SYS___HYPOTL_B = 0x858 +- SYS___LOG1PF_B = 0x859 +- SYS___REMQUOF_B = 0x860 +- SYS___REMQUO_B = 0x861 +- SYS___REMQUOL_B = 0x862 +- SYS___TGAMMAF_B = 0x863 +- SYS___TGAMMA_B = 0x864 +- SYS___TGAMMAL_B = 0x865 +- SYS___TRUNCF_B = 0x866 +- SYS___TRUNC_B = 0x867 +- SYS___TRUNCL_B = 0x868 +- SYS___LGAMMAF_B = 0x869 +- SYS_ASINHF = 0x870 +- SYS_ASINHL = 0x871 +- SYS_ATANHF = 0x872 +- SYS_ATANHL = 0x873 +- SYS_CBRTF = 0x874 +- SYS_CBRTL = 0x875 +- SYS_COPYSIGNF = 0x876 +- SYS_CPYSIGNF = 0x876 +- SYS_COPYSIGNL = 0x877 +- SYS_CPYSIGNL = 0x877 +- SYS_COTANF = 0x878 +- SYS___COTANF = 0x878 +- SYS_COTAN = 0x879 +- SYS___COTAN = 0x879 +- SYS_FDIM = 0x881 +- SYS_FDIML = 0x882 +- SYS_HYPOTF = 0x883 +- SYS_HYPOTL = 0x884 +- SYS_LOG1PF = 0x885 +- SYS_LOG1PL = 0x886 +- SYS_LOG2F = 0x887 +- SYS_LOG2 = 0x888 +- SYS_LOG2L = 0x889 +- SYS_TGAMMA = 0x890 +- SYS_TGAMMAL = 0x891 +- SYS_TRUNCF = 0x892 +- SYS_TRUNC = 0x893 +- SYS_TRUNCL = 0x894 +- SYS_LGAMMAF = 0x895 +- SYS_LGAMMAL = 0x896 +- SYS_LROUNDF = 0x897 +- SYS_LROUND = 0x898 +- SYS_ERFF = 0x899 +- SYS___COSHF_H = 0x900 +- SYS___COSHL_H = 0x901 +- SYS___COTAN_H = 0x902 +- SYS___COTANF_H = 0x903 +- SYS___COTANL_H = 0x904 +- SYS___ERF_H = 0x905 +- SYS___ERFF_H = 0x906 +- SYS___ERFL_H = 0x907 +- SYS___ERFC_H = 0x908 +- SYS___ERFCF_H = 0x909 +- SYS___FDIMF_H = 0x910 +- SYS___FDIML_H = 0x911 +- SYS___FMOD_H = 0x912 +- SYS___FMODF_H = 0x913 +- SYS___FMODL_H = 0x914 +- SYS___GAMMA_H = 0x915 +- SYS___HYPOT_H = 0x916 +- SYS___ILOGB_H = 0x917 +- SYS___LGAMMA_H = 0x918 +- SYS___LGAMMAF_H = 0x919 +- SYS___LOG2L_H = 0x920 +- SYS___LOG1P_H = 0x921 +- SYS___LOG10_H = 0x922 +- SYS___LOG10F_H = 0x923 +- SYS___LOG10L_H = 0x924 +- SYS___LROUND_H = 0x925 +- SYS___LROUNDF_H = 0x926 +- SYS___NEXTAFTER_H = 0x927 +- SYS___POW_H = 0x928 +- SYS___POWF_H = 0x929 +- SYS___SINL_H = 0x930 +- SYS___SINH_H = 0x931 +- SYS___SINHF_H = 0x932 +- SYS___SINHL_H = 0x933 +- SYS___SQRT_H = 0x934 +- SYS___SQRTF_H = 0x935 +- SYS___SQRTL_H = 0x936 +- SYS___TAN_H = 0x937 +- SYS___TANF_H = 0x938 +- SYS___TANL_H = 0x939 +- SYS___TRUNCF_H = 0x940 +- SYS___TRUNCL_H = 0x941 +- SYS___COSH_H = 0x942 +- SYS___LE_DEBUG_SET_RESUME_MCH = 0x943 +- SYS_VFSCANF = 0x944 +- SYS_VSCANF = 0x946 +- SYS_VSSCANF = 0x948 +- SYS_IMAXABS = 0x950 +- SYS_IMAXDIV = 0x951 +- SYS_STRTOIMAX = 0x952 +- SYS_STRTOUMAX = 0x953 +- SYS_WCSTOIMAX = 0x954 +- SYS_WCSTOUMAX = 0x955 +- SYS_ATOLL = 0x956 +- SYS_STRTOF = 0x957 +- SYS_STRTOLD = 0x958 +- SYS_WCSTOF = 0x959 +- SYS_INET6_RTH_GETADDR = 0x960 +- SYS_INET6_OPT_INIT = 0x961 +- SYS_INET6_OPT_APPEND = 0x962 +- SYS_INET6_OPT_FINISH = 0x963 +- SYS_INET6_OPT_SET_VAL = 0x964 +- SYS_INET6_OPT_NEXT = 0x965 +- SYS_INET6_OPT_FIND = 0x966 +- SYS_INET6_OPT_GET_VAL = 0x967 +- SYS___POW_I = 0x987 +- SYS___POW_I_B = 0x988 +- SYS___POW_I_H = 0x989 +- SYS___CABS_H = 0x990 +- SYS_CABSF = 0x991 +- SYS___CABSF_B = 0x992 +- SYS___CABSF_H = 0x993 +- SYS_CABSL = 0x994 +- SYS___CABSL_B = 0x995 +- SYS___CABSL_H = 0x996 +- SYS_CACOS = 0x997 +- SYS___CACOS_B = 0x998 +- SYS___CACOS_H = 0x999 ++ SYS_LOG = 0x17 // 23 ++ SYS_COSH = 0x18 // 24 ++ SYS_TANH = 0x19 // 25 ++ SYS_EXP = 0x1A // 26 ++ SYS_MODF = 0x1B // 27 ++ SYS_LOG10 = 0x1C // 28 ++ SYS_FREXP = 0x1D // 29 ++ SYS_LDEXP = 0x1E // 30 ++ SYS_CEIL = 0x1F // 31 ++ SYS_POW = 0x20 // 32 ++ SYS_SQRT = 0x21 // 33 ++ SYS_FLOOR = 0x22 // 34 ++ SYS_J1 = 0x23 // 35 ++ SYS_FABS = 0x24 // 36 ++ SYS_FMOD = 0x25 // 37 ++ SYS_J0 = 0x26 // 38 ++ SYS_YN = 0x27 // 39 ++ SYS_JN = 0x28 // 40 ++ SYS_Y0 = 0x29 // 41 ++ SYS_Y1 = 0x2A // 42 ++ SYS_HYPOT = 0x2B // 43 ++ SYS_ERF = 0x2C // 44 ++ SYS_ERFC = 0x2D // 45 ++ SYS_GAMMA = 0x2E // 46 ++ SYS_ISALPHA = 0x30 // 48 ++ SYS_ISALNUM = 0x31 // 49 ++ SYS_ISLOWER = 0x32 // 50 ++ SYS_ISCNTRL = 0x33 // 51 ++ SYS_ISDIGIT = 0x34 // 52 ++ SYS_ISGRAPH = 0x35 // 53 ++ SYS_ISUPPER = 0x36 // 54 ++ SYS_ISPRINT = 0x37 // 55 ++ SYS_ISPUNCT = 0x38 // 56 ++ SYS_ISSPACE = 0x39 // 57 ++ SYS_SETLOCAL = 0x3A // 58 ++ SYS_SETLOCALE = 0x3A // 58 ++ SYS_ISXDIGIT = 0x3B // 59 ++ SYS_TOLOWER = 0x3C // 60 ++ SYS_TOUPPER = 0x3D // 61 ++ SYS_ASIN = 0x3E // 62 ++ SYS_SIN = 0x3F // 63 ++ SYS_COS = 0x40 // 64 ++ SYS_TAN = 0x41 // 65 ++ SYS_SINH = 0x42 // 66 ++ SYS_ACOS = 0x43 // 67 ++ SYS_ATAN = 0x44 // 68 ++ SYS_ATAN2 = 0x45 // 69 ++ SYS_FTELL = 0x46 // 70 ++ SYS_FGETPOS = 0x47 // 71 ++ SYS_FSEEK = 0x48 // 72 ++ SYS_FSETPOS = 0x49 // 73 ++ SYS_FERROR = 0x4A // 74 ++ SYS_REWIND = 0x4B // 75 ++ SYS_CLEARERR = 0x4C // 76 ++ SYS_FEOF = 0x4D // 77 ++ SYS_ATOL = 0x4E // 78 ++ SYS_PERROR = 0x4F // 79 ++ SYS_ATOF = 0x50 // 80 ++ SYS_ATOI = 0x51 // 81 ++ SYS_RAND = 0x52 // 82 ++ SYS_STRTOD = 0x53 // 83 ++ SYS_STRTOL = 0x54 // 84 ++ SYS_STRTOUL = 0x55 // 85 ++ SYS_MALLOC = 0x56 // 86 ++ SYS_SRAND = 0x57 // 87 ++ SYS_CALLOC = 0x58 // 88 ++ SYS_FREE = 0x59 // 89 ++ SYS_EXIT = 0x5A // 90 ++ SYS_REALLOC = 0x5B // 91 ++ SYS_ABORT = 0x5C // 92 ++ SYS___ABORT = 0x5C // 92 ++ SYS_ATEXIT = 0x5D // 93 ++ SYS_RAISE = 0x5E // 94 ++ SYS_SETJMP = 0x5F // 95 ++ SYS_LONGJMP = 0x60 // 96 ++ SYS_SIGNAL = 0x61 // 97 ++ SYS_TMPNAM = 0x62 // 98 ++ SYS_REMOVE = 0x63 // 99 ++ SYS_RENAME = 0x64 // 100 ++ SYS_TMPFILE = 0x65 // 101 ++ SYS_FREOPEN = 0x66 // 102 ++ SYS_FCLOSE = 0x67 // 103 ++ SYS_FFLUSH = 0x68 // 104 ++ SYS_FOPEN = 0x69 // 105 ++ SYS_FSCANF = 0x6A // 106 ++ SYS_SETBUF = 0x6B // 107 ++ SYS_SETVBUF = 0x6C // 108 ++ SYS_FPRINTF = 0x6D // 109 ++ SYS_SSCANF = 0x6E // 110 ++ SYS_PRINTF = 0x6F // 111 ++ SYS_SCANF = 0x70 // 112 ++ SYS_SPRINTF = 0x71 // 113 ++ SYS_FGETC = 0x72 // 114 ++ SYS_VFPRINTF = 0x73 // 115 ++ SYS_VPRINTF = 0x74 // 116 ++ SYS_VSPRINTF = 0x75 // 117 ++ SYS_GETC = 0x76 // 118 ++ SYS_FGETS = 0x77 // 119 ++ SYS_FPUTC = 0x78 // 120 ++ SYS_FPUTS = 0x79 // 121 ++ SYS_PUTCHAR = 0x7A // 122 ++ SYS_GETCHAR = 0x7B // 123 ++ SYS_GETS = 0x7C // 124 ++ SYS_PUTC = 0x7D // 125 ++ SYS_FWRITE = 0x7E // 126 ++ SYS_PUTS = 0x7F // 127 ++ SYS_UNGETC = 0x80 // 128 ++ SYS_FREAD = 0x81 // 129 ++ SYS_WCSTOMBS = 0x82 // 130 ++ SYS_MBTOWC = 0x83 // 131 ++ SYS_WCTOMB = 0x84 // 132 ++ SYS_MBSTOWCS = 0x85 // 133 ++ SYS_WCSCPY = 0x86 // 134 ++ SYS_WCSCAT = 0x87 // 135 ++ SYS_WCSCHR = 0x88 // 136 ++ SYS_WCSCMP = 0x89 // 137 ++ SYS_WCSNCMP = 0x8A // 138 ++ SYS_WCSCSPN = 0x8B // 139 ++ SYS_WCSLEN = 0x8C // 140 ++ SYS_WCSNCAT = 0x8D // 141 ++ SYS_WCSSPN = 0x8E // 142 ++ SYS_WCSNCPY = 0x8F // 143 ++ SYS_ABS = 0x90 // 144 ++ SYS_DIV = 0x91 // 145 ++ SYS_LABS = 0x92 // 146 ++ SYS_STRNCPY = 0x93 // 147 ++ SYS_MEMCPY = 0x94 // 148 ++ SYS_MEMMOVE = 0x95 // 149 ++ SYS_STRCPY = 0x96 // 150 ++ SYS_STRCMP = 0x97 // 151 ++ SYS_STRCAT = 0x98 // 152 ++ SYS_STRNCAT = 0x99 // 153 ++ SYS_MEMCMP = 0x9A // 154 ++ SYS_MEMCHR = 0x9B // 155 ++ SYS_STRCOLL = 0x9C // 156 ++ SYS_STRNCMP = 0x9D // 157 ++ SYS_STRXFRM = 0x9E // 158 ++ SYS_STRRCHR = 0x9F // 159 ++ SYS_STRCHR = 0xA0 // 160 ++ SYS_STRCSPN = 0xA1 // 161 ++ SYS_STRPBRK = 0xA2 // 162 ++ SYS_MEMSET = 0xA3 // 163 ++ SYS_STRSPN = 0xA4 // 164 ++ SYS_STRSTR = 0xA5 // 165 ++ SYS_STRTOK = 0xA6 // 166 ++ SYS_DIFFTIME = 0xA7 // 167 ++ SYS_STRERROR = 0xA8 // 168 ++ SYS_STRLEN = 0xA9 // 169 ++ SYS_CLOCK = 0xAA // 170 ++ SYS_CTIME = 0xAB // 171 ++ SYS_MKTIME = 0xAC // 172 ++ SYS_TIME = 0xAD // 173 ++ SYS_ASCTIME = 0xAE // 174 ++ SYS_MBLEN = 0xAF // 175 ++ SYS_GMTIME = 0xB0 // 176 ++ SYS_LOCALTIM = 0xB1 // 177 ++ SYS_LOCALTIME = 0xB1 // 177 ++ SYS_STRFTIME = 0xB2 // 178 ++ SYS___GETCB = 0xB4 // 180 ++ SYS_FUPDATE = 0xB5 // 181 ++ SYS___FUPDT = 0xB5 // 181 ++ SYS_CLRMEMF = 0xBD // 189 ++ SYS___CLRMF = 0xBD // 189 ++ SYS_FETCHEP = 0xBF // 191 ++ SYS___FTCHEP = 0xBF // 191 ++ SYS_FLDATA = 0xC1 // 193 ++ SYS___FLDATA = 0xC1 // 193 ++ SYS_DYNFREE = 0xC2 // 194 ++ SYS___DYNFRE = 0xC2 // 194 ++ SYS_DYNALLOC = 0xC3 // 195 ++ SYS___DYNALL = 0xC3 // 195 ++ SYS___CDUMP = 0xC4 // 196 ++ SYS_CSNAP = 0xC5 // 197 ++ SYS___CSNAP = 0xC5 // 197 ++ SYS_CTRACE = 0xC6 // 198 ++ SYS___CTRACE = 0xC6 // 198 ++ SYS___CTEST = 0xC7 // 199 ++ SYS_SETENV = 0xC8 // 200 ++ SYS___SETENV = 0xC8 // 200 ++ SYS_CLEARENV = 0xC9 // 201 ++ SYS___CLRENV = 0xC9 // 201 ++ SYS___REGCOMP_STD = 0xEA // 234 ++ SYS_NL_LANGINFO = 0xFC // 252 ++ SYS_GETSYNTX = 0xFD // 253 ++ SYS_ISBLANK = 0xFE // 254 ++ SYS___ISBLNK = 0xFE // 254 ++ SYS_ISWALNUM = 0xFF // 255 ++ SYS_ISWALPHA = 0x100 // 256 ++ SYS_ISWBLANK = 0x101 // 257 ++ SYS___ISWBLK = 0x101 // 257 ++ SYS_ISWCNTRL = 0x102 // 258 ++ SYS_ISWDIGIT = 0x103 // 259 ++ SYS_ISWGRAPH = 0x104 // 260 ++ SYS_ISWLOWER = 0x105 // 261 ++ SYS_ISWPRINT = 0x106 // 262 ++ SYS_ISWPUNCT = 0x107 // 263 ++ SYS_ISWSPACE = 0x108 // 264 ++ SYS_ISWUPPER = 0x109 // 265 ++ SYS_ISWXDIGI = 0x10A // 266 ++ SYS_ISWXDIGIT = 0x10A // 266 ++ SYS_WCTYPE = 0x10B // 267 ++ SYS_ISWCTYPE = 0x10C // 268 ++ SYS_TOWLOWER = 0x10D // 269 ++ SYS_TOWUPPER = 0x10E // 270 ++ SYS_MBSINIT = 0x10F // 271 ++ SYS_WCTOB = 0x110 // 272 ++ SYS_MBRLEN = 0x111 // 273 ++ SYS_MBRTOWC = 0x112 // 274 ++ SYS_MBSRTOWC = 0x113 // 275 ++ SYS_MBSRTOWCS = 0x113 // 275 ++ SYS_WCRTOMB = 0x114 // 276 ++ SYS_WCSRTOMB = 0x115 // 277 ++ SYS_WCSRTOMBS = 0x115 // 277 ++ SYS___CSID = 0x116 // 278 ++ SYS___WCSID = 0x117 // 279 ++ SYS_STRPTIME = 0x118 // 280 ++ SYS___STRPTM = 0x118 // 280 ++ SYS_STRFMON = 0x119 // 281 ++ SYS___RPMTCH = 0x11A // 282 ++ SYS_WCSSTR = 0x11B // 283 ++ SYS_WCSTOK = 0x12C // 300 ++ SYS_WCSTOL = 0x12D // 301 ++ SYS_WCSTOD = 0x12E // 302 ++ SYS_WCSTOUL = 0x12F // 303 ++ SYS_WCSCOLL = 0x130 // 304 ++ SYS_WCSXFRM = 0x131 // 305 ++ SYS_WCSWIDTH = 0x132 // 306 ++ SYS_WCWIDTH = 0x133 // 307 ++ SYS_WCSFTIME = 0x134 // 308 ++ SYS_SWPRINTF = 0x135 // 309 ++ SYS_VSWPRINT = 0x136 // 310 ++ SYS_VSWPRINTF = 0x136 // 310 ++ SYS_SWSCANF = 0x137 // 311 ++ SYS_REGCOMP = 0x138 // 312 ++ SYS_REGEXEC = 0x139 // 313 ++ SYS_REGFREE = 0x13A // 314 ++ SYS_REGERROR = 0x13B // 315 ++ SYS_FGETWC = 0x13C // 316 ++ SYS_FGETWS = 0x13D // 317 ++ SYS_FPUTWC = 0x13E // 318 ++ SYS_FPUTWS = 0x13F // 319 ++ SYS_GETWC = 0x140 // 320 ++ SYS_GETWCHAR = 0x141 // 321 ++ SYS_PUTWC = 0x142 // 322 ++ SYS_PUTWCHAR = 0x143 // 323 ++ SYS_UNGETWC = 0x144 // 324 ++ SYS_ICONV_OPEN = 0x145 // 325 ++ SYS_ICONV = 0x146 // 326 ++ SYS_ICONV_CLOSE = 0x147 // 327 ++ SYS_ISMCCOLLEL = 0x14C // 332 ++ SYS_STRTOCOLL = 0x14D // 333 ++ SYS_COLLTOSTR = 0x14E // 334 ++ SYS_COLLEQUIV = 0x14F // 335 ++ SYS_COLLRANGE = 0x150 // 336 ++ SYS_CCLASS = 0x151 // 337 ++ SYS_COLLORDER = 0x152 // 338 ++ SYS___DEMANGLE = 0x154 // 340 ++ SYS_FDOPEN = 0x155 // 341 ++ SYS___ERRNO = 0x156 // 342 ++ SYS___ERRNO2 = 0x157 // 343 ++ SYS___TERROR = 0x158 // 344 ++ SYS_MAXCOLL = 0x169 // 361 ++ SYS_GETMCCOLL = 0x16A // 362 ++ SYS_GETWMCCOLL = 0x16B // 363 ++ SYS___ERR2AD = 0x16C // 364 ++ SYS_DLLQUERYFN = 0x16D // 365 ++ SYS_DLLQUERYVAR = 0x16E // 366 ++ SYS_DLLFREE = 0x16F // 367 ++ SYS_DLLLOAD = 0x170 // 368 ++ SYS__EXIT = 0x174 // 372 ++ SYS_ACCESS = 0x175 // 373 ++ SYS_ALARM = 0x176 // 374 ++ SYS_CFGETISPEED = 0x177 // 375 ++ SYS_CFGETOSPEED = 0x178 // 376 ++ SYS_CFSETISPEED = 0x179 // 377 ++ SYS_CFSETOSPEED = 0x17A // 378 ++ SYS_CHDIR = 0x17B // 379 ++ SYS_CHMOD = 0x17C // 380 ++ SYS_CHOWN = 0x17D // 381 ++ SYS_CLOSE = 0x17E // 382 ++ SYS_CLOSEDIR = 0x17F // 383 ++ SYS_CREAT = 0x180 // 384 ++ SYS_CTERMID = 0x181 // 385 ++ SYS_DUP = 0x182 // 386 ++ SYS_DUP2 = 0x183 // 387 ++ SYS_EXECL = 0x184 // 388 ++ SYS_EXECLE = 0x185 // 389 ++ SYS_EXECLP = 0x186 // 390 ++ SYS_EXECV = 0x187 // 391 ++ SYS_EXECVE = 0x188 // 392 ++ SYS_EXECVP = 0x189 // 393 ++ SYS_FCHMOD = 0x18A // 394 ++ SYS_FCHOWN = 0x18B // 395 ++ SYS_FCNTL = 0x18C // 396 ++ SYS_FILENO = 0x18D // 397 ++ SYS_FORK = 0x18E // 398 ++ SYS_FPATHCONF = 0x18F // 399 ++ SYS_FSTAT = 0x190 // 400 ++ SYS_FSYNC = 0x191 // 401 ++ SYS_FTRUNCATE = 0x192 // 402 ++ SYS_GETCWD = 0x193 // 403 ++ SYS_GETEGID = 0x194 // 404 ++ SYS_GETEUID = 0x195 // 405 ++ SYS_GETGID = 0x196 // 406 ++ SYS_GETGRGID = 0x197 // 407 ++ SYS_GETGRNAM = 0x198 // 408 ++ SYS_GETGROUPS = 0x199 // 409 ++ SYS_GETLOGIN = 0x19A // 410 ++ SYS_W_GETMNTENT = 0x19B // 411 ++ SYS_GETPGRP = 0x19C // 412 ++ SYS_GETPID = 0x19D // 413 ++ SYS_GETPPID = 0x19E // 414 ++ SYS_GETPWNAM = 0x19F // 415 ++ SYS_GETPWUID = 0x1A0 // 416 ++ SYS_GETUID = 0x1A1 // 417 ++ SYS_W_IOCTL = 0x1A2 // 418 ++ SYS_ISATTY = 0x1A3 // 419 ++ SYS_KILL = 0x1A4 // 420 ++ SYS_LINK = 0x1A5 // 421 ++ SYS_LSEEK = 0x1A6 // 422 ++ SYS_LSTAT = 0x1A7 // 423 ++ SYS_MKDIR = 0x1A8 // 424 ++ SYS_MKFIFO = 0x1A9 // 425 ++ SYS_MKNOD = 0x1AA // 426 ++ SYS_MOUNT = 0x1AB // 427 ++ SYS_OPEN = 0x1AC // 428 ++ SYS_OPENDIR = 0x1AD // 429 ++ SYS_PATHCONF = 0x1AE // 430 ++ SYS_PAUSE = 0x1AF // 431 ++ SYS_PIPE = 0x1B0 // 432 ++ SYS_W_GETPSENT = 0x1B1 // 433 ++ SYS_READ = 0x1B2 // 434 ++ SYS_READDIR = 0x1B3 // 435 ++ SYS_READLINK = 0x1B4 // 436 ++ SYS_REWINDDIR = 0x1B5 // 437 ++ SYS_RMDIR = 0x1B6 // 438 ++ SYS_SETEGID = 0x1B7 // 439 ++ SYS_SETEUID = 0x1B8 // 440 ++ SYS_SETGID = 0x1B9 // 441 ++ SYS_SETPGID = 0x1BA // 442 ++ SYS_SETSID = 0x1BB // 443 ++ SYS_SETUID = 0x1BC // 444 ++ SYS_SIGACTION = 0x1BD // 445 ++ SYS_SIGADDSET = 0x1BE // 446 ++ SYS_SIGDELSET = 0x1BF // 447 ++ SYS_SIGEMPTYSET = 0x1C0 // 448 ++ SYS_SIGFILLSET = 0x1C1 // 449 ++ SYS_SIGISMEMBER = 0x1C2 // 450 ++ SYS_SIGLONGJMP = 0x1C3 // 451 ++ SYS_SIGPENDING = 0x1C4 // 452 ++ SYS_SIGPROCMASK = 0x1C5 // 453 ++ SYS_SIGSETJMP = 0x1C6 // 454 ++ SYS_SIGSUSPEND = 0x1C7 // 455 ++ SYS_SLEEP = 0x1C8 // 456 ++ SYS_STAT = 0x1C9 // 457 ++ SYS_W_STATFS = 0x1CA // 458 ++ SYS_SYMLINK = 0x1CB // 459 ++ SYS_SYSCONF = 0x1CC // 460 ++ SYS_TCDRAIN = 0x1CD // 461 ++ SYS_TCFLOW = 0x1CE // 462 ++ SYS_TCFLUSH = 0x1CF // 463 ++ SYS_TCGETATTR = 0x1D0 // 464 ++ SYS_TCGETPGRP = 0x1D1 // 465 ++ SYS_TCSENDBREAK = 0x1D2 // 466 ++ SYS_TCSETATTR = 0x1D3 // 467 ++ SYS_TCSETPGRP = 0x1D4 // 468 ++ SYS_TIMES = 0x1D5 // 469 ++ SYS_TTYNAME = 0x1D6 // 470 ++ SYS_TZSET = 0x1D7 // 471 ++ SYS_UMASK = 0x1D8 // 472 ++ SYS_UMOUNT = 0x1D9 // 473 ++ SYS_UNAME = 0x1DA // 474 ++ SYS_UNLINK = 0x1DB // 475 ++ SYS_UTIME = 0x1DC // 476 ++ SYS_WAIT = 0x1DD // 477 ++ SYS_WAITPID = 0x1DE // 478 ++ SYS_WRITE = 0x1DF // 479 ++ SYS_CHAUDIT = 0x1E0 // 480 ++ SYS_FCHAUDIT = 0x1E1 // 481 ++ SYS_GETGROUPSBYNAME = 0x1E2 // 482 ++ SYS_SIGWAIT = 0x1E3 // 483 ++ SYS_PTHREAD_EXIT = 0x1E4 // 484 ++ SYS_PTHREAD_KILL = 0x1E5 // 485 ++ SYS_PTHREAD_ATTR_INIT = 0x1E6 // 486 ++ SYS_PTHREAD_ATTR_DESTROY = 0x1E7 // 487 ++ SYS_PTHREAD_ATTR_SETSTACKSIZE = 0x1E8 // 488 ++ SYS_PTHREAD_ATTR_GETSTACKSIZE = 0x1E9 // 489 ++ SYS_PTHREAD_ATTR_SETDETACHSTATE = 0x1EA // 490 ++ SYS_PTHREAD_ATTR_GETDETACHSTATE = 0x1EB // 491 ++ SYS_PTHREAD_ATTR_SETWEIGHT_NP = 0x1EC // 492 ++ SYS_PTHREAD_ATTR_GETWEIGHT_NP = 0x1ED // 493 ++ SYS_PTHREAD_CANCEL = 0x1EE // 494 ++ SYS_PTHREAD_CLEANUP_PUSH = 0x1EF // 495 ++ SYS_PTHREAD_CLEANUP_POP = 0x1F0 // 496 ++ SYS_PTHREAD_CONDATTR_INIT = 0x1F1 // 497 ++ SYS_PTHREAD_CONDATTR_DESTROY = 0x1F2 // 498 ++ SYS_PTHREAD_COND_INIT = 0x1F3 // 499 ++ SYS_PTHREAD_COND_DESTROY = 0x1F4 // 500 ++ SYS_PTHREAD_COND_SIGNAL = 0x1F5 // 501 ++ SYS_PTHREAD_COND_BROADCAST = 0x1F6 // 502 ++ SYS_PTHREAD_COND_WAIT = 0x1F7 // 503 ++ SYS_PTHREAD_COND_TIMEDWAIT = 0x1F8 // 504 ++ SYS_PTHREAD_CREATE = 0x1F9 // 505 ++ SYS_PTHREAD_DETACH = 0x1FA // 506 ++ SYS_PTHREAD_EQUAL = 0x1FB // 507 ++ SYS_PTHREAD_GETSPECIFIC = 0x1FC // 508 ++ SYS_PTHREAD_JOIN = 0x1FD // 509 ++ SYS_PTHREAD_KEY_CREATE = 0x1FE // 510 ++ SYS_PTHREAD_MUTEXATTR_INIT = 0x1FF // 511 ++ SYS_PTHREAD_MUTEXATTR_DESTROY = 0x200 // 512 ++ SYS_PTHREAD_MUTEXATTR_SETKIND_NP = 0x201 // 513 ++ SYS_PTHREAD_MUTEXATTR_GETKIND_NP = 0x202 // 514 ++ SYS_PTHREAD_MUTEX_INIT = 0x203 // 515 ++ SYS_PTHREAD_MUTEX_DESTROY = 0x204 // 516 ++ SYS_PTHREAD_MUTEX_LOCK = 0x205 // 517 ++ SYS_PTHREAD_MUTEX_TRYLOCK = 0x206 // 518 ++ SYS_PTHREAD_MUTEX_UNLOCK = 0x207 // 519 ++ SYS_PTHREAD_ONCE = 0x209 // 521 ++ SYS_PTHREAD_SELF = 0x20A // 522 ++ SYS_PTHREAD_SETINTR = 0x20B // 523 ++ SYS_PTHREAD_SETINTRTYPE = 0x20C // 524 ++ SYS_PTHREAD_SETSPECIFIC = 0x20D // 525 ++ SYS_PTHREAD_TESTINTR = 0x20E // 526 ++ SYS_PTHREAD_YIELD = 0x20F // 527 ++ SYS_TW_OPEN = 0x210 // 528 ++ SYS_TW_FCNTL = 0x211 // 529 ++ SYS_PTHREAD_JOIN_D4_NP = 0x212 // 530 ++ SYS_PTHREAD_CONDATTR_SETKIND_NP = 0x213 // 531 ++ SYS_PTHREAD_CONDATTR_GETKIND_NP = 0x214 // 532 ++ SYS_EXTLINK_NP = 0x215 // 533 ++ SYS___PASSWD = 0x216 // 534 ++ SYS_SETGROUPS = 0x217 // 535 ++ SYS_INITGROUPS = 0x218 // 536 ++ SYS_WCSPBRK = 0x23F // 575 ++ SYS_WCSRCHR = 0x240 // 576 ++ SYS_SVC99 = 0x241 // 577 ++ SYS___SVC99 = 0x241 // 577 ++ SYS_WCSWCS = 0x242 // 578 ++ SYS_LOCALECO = 0x243 // 579 ++ SYS_LOCALECONV = 0x243 // 579 ++ SYS___LIBREL = 0x244 // 580 ++ SYS_RELEASE = 0x245 // 581 ++ SYS___RLSE = 0x245 // 581 ++ SYS_FLOCATE = 0x246 // 582 ++ SYS___FLOCT = 0x246 // 582 ++ SYS_FDELREC = 0x247 // 583 ++ SYS___FDLREC = 0x247 // 583 ++ SYS_FETCH = 0x248 // 584 ++ SYS___FETCH = 0x248 // 584 ++ SYS_QSORT = 0x249 // 585 ++ SYS_GETENV = 0x24A // 586 ++ SYS_SYSTEM = 0x24B // 587 ++ SYS_BSEARCH = 0x24C // 588 ++ SYS_LDIV = 0x24D // 589 ++ SYS___THROW = 0x25E // 606 ++ SYS___RETHROW = 0x25F // 607 ++ SYS___CLEANUPCATCH = 0x260 // 608 ++ SYS___CATCHMATCH = 0x261 // 609 ++ SYS___CLEAN2UPCATCH = 0x262 // 610 ++ SYS_PUTENV = 0x26A // 618 ++ SYS___GETENV = 0x26F // 623 ++ SYS_GETPRIORITY = 0x270 // 624 ++ SYS_NICE = 0x271 // 625 ++ SYS_SETPRIORITY = 0x272 // 626 ++ SYS_GETITIMER = 0x273 // 627 ++ SYS_SETITIMER = 0x274 // 628 ++ SYS_MSGCTL = 0x275 // 629 ++ SYS_MSGGET = 0x276 // 630 ++ SYS_MSGRCV = 0x277 // 631 ++ SYS_MSGSND = 0x278 // 632 ++ SYS_MSGXRCV = 0x279 // 633 ++ SYS___MSGXR = 0x279 // 633 ++ SYS_SEMCTL = 0x27A // 634 ++ SYS_SEMGET = 0x27B // 635 ++ SYS_SEMOP = 0x27C // 636 ++ SYS_SHMAT = 0x27D // 637 ++ SYS_SHMCTL = 0x27E // 638 ++ SYS_SHMDT = 0x27F // 639 ++ SYS_SHMGET = 0x280 // 640 ++ SYS___GETIPC = 0x281 // 641 ++ SYS_SETGRENT = 0x282 // 642 ++ SYS_GETGRENT = 0x283 // 643 ++ SYS_ENDGRENT = 0x284 // 644 ++ SYS_SETPWENT = 0x285 // 645 ++ SYS_GETPWENT = 0x286 // 646 ++ SYS_ENDPWENT = 0x287 // 647 ++ SYS_BSD_SIGNAL = 0x288 // 648 ++ SYS_KILLPG = 0x289 // 649 ++ SYS_SIGALTSTACK = 0x28A // 650 ++ SYS_SIGHOLD = 0x28B // 651 ++ SYS_SIGIGNORE = 0x28C // 652 ++ SYS_SIGINTERRUPT = 0x28D // 653 ++ SYS_SIGPAUSE = 0x28E // 654 ++ SYS_SIGRELSE = 0x28F // 655 ++ SYS_SIGSET = 0x290 // 656 ++ SYS_SIGSTACK = 0x291 // 657 ++ SYS_GETRLIMIT = 0x292 // 658 ++ SYS_SETRLIMIT = 0x293 // 659 ++ SYS_GETRUSAGE = 0x294 // 660 ++ SYS_MMAP = 0x295 // 661 ++ SYS_MPROTECT = 0x296 // 662 ++ SYS_MSYNC = 0x297 // 663 ++ SYS_MUNMAP = 0x298 // 664 ++ SYS_CONFSTR = 0x299 // 665 ++ SYS_GETOPT = 0x29A // 666 ++ SYS_LCHOWN = 0x29B // 667 ++ SYS_TRUNCATE = 0x29C // 668 ++ SYS_GETSUBOPT = 0x29D // 669 ++ SYS_SETPGRP = 0x29E // 670 ++ SYS___GDERR = 0x29F // 671 ++ SYS___TZONE = 0x2A0 // 672 ++ SYS___DLGHT = 0x2A1 // 673 ++ SYS___OPARGF = 0x2A2 // 674 ++ SYS___OPOPTF = 0x2A3 // 675 ++ SYS___OPINDF = 0x2A4 // 676 ++ SYS___OPERRF = 0x2A5 // 677 ++ SYS_GETDATE = 0x2A6 // 678 ++ SYS_WAIT3 = 0x2A7 // 679 ++ SYS_WAITID = 0x2A8 // 680 ++ SYS___CATTRM = 0x2A9 // 681 ++ SYS___GDTRM = 0x2AA // 682 ++ SYS___RNDTRM = 0x2AB // 683 ++ SYS_CRYPT = 0x2AC // 684 ++ SYS_ENCRYPT = 0x2AD // 685 ++ SYS_SETKEY = 0x2AE // 686 ++ SYS___CNVBLK = 0x2AF // 687 ++ SYS___CRYTRM = 0x2B0 // 688 ++ SYS___ECRTRM = 0x2B1 // 689 ++ SYS_DRAND48 = 0x2B2 // 690 ++ SYS_ERAND48 = 0x2B3 // 691 ++ SYS_FSTATVFS = 0x2B4 // 692 ++ SYS_STATVFS = 0x2B5 // 693 ++ SYS_CATCLOSE = 0x2B6 // 694 ++ SYS_CATGETS = 0x2B7 // 695 ++ SYS_CATOPEN = 0x2B8 // 696 ++ SYS_BCMP = 0x2B9 // 697 ++ SYS_BCOPY = 0x2BA // 698 ++ SYS_BZERO = 0x2BB // 699 ++ SYS_FFS = 0x2BC // 700 ++ SYS_INDEX = 0x2BD // 701 ++ SYS_RINDEX = 0x2BE // 702 ++ SYS_STRCASECMP = 0x2BF // 703 ++ SYS_STRDUP = 0x2C0 // 704 ++ SYS_STRNCASECMP = 0x2C1 // 705 ++ SYS_INITSTATE = 0x2C2 // 706 ++ SYS_SETSTATE = 0x2C3 // 707 ++ SYS_RANDOM = 0x2C4 // 708 ++ SYS_SRANDOM = 0x2C5 // 709 ++ SYS_HCREATE = 0x2C6 // 710 ++ SYS_HDESTROY = 0x2C7 // 711 ++ SYS_HSEARCH = 0x2C8 // 712 ++ SYS_LFIND = 0x2C9 // 713 ++ SYS_LSEARCH = 0x2CA // 714 ++ SYS_TDELETE = 0x2CB // 715 ++ SYS_TFIND = 0x2CC // 716 ++ SYS_TSEARCH = 0x2CD // 717 ++ SYS_TWALK = 0x2CE // 718 ++ SYS_INSQUE = 0x2CF // 719 ++ SYS_REMQUE = 0x2D0 // 720 ++ SYS_POPEN = 0x2D1 // 721 ++ SYS_PCLOSE = 0x2D2 // 722 ++ SYS_SWAB = 0x2D3 // 723 ++ SYS_MEMCCPY = 0x2D4 // 724 ++ SYS_GETPAGESIZE = 0x2D8 // 728 ++ SYS_FCHDIR = 0x2D9 // 729 ++ SYS___OCLCK = 0x2DA // 730 ++ SYS___ATOE = 0x2DB // 731 ++ SYS___ATOE_L = 0x2DC // 732 ++ SYS___ETOA = 0x2DD // 733 ++ SYS___ETOA_L = 0x2DE // 734 ++ SYS_SETUTXENT = 0x2DF // 735 ++ SYS_GETUTXENT = 0x2E0 // 736 ++ SYS_ENDUTXENT = 0x2E1 // 737 ++ SYS_GETUTXID = 0x2E2 // 738 ++ SYS_GETUTXLINE = 0x2E3 // 739 ++ SYS_PUTUTXLINE = 0x2E4 // 740 ++ SYS_FMTMSG = 0x2E5 // 741 ++ SYS_JRAND48 = 0x2E6 // 742 ++ SYS_LRAND48 = 0x2E7 // 743 ++ SYS_MRAND48 = 0x2E8 // 744 ++ SYS_NRAND48 = 0x2E9 // 745 ++ SYS_LCONG48 = 0x2EA // 746 ++ SYS_SRAND48 = 0x2EB // 747 ++ SYS_SEED48 = 0x2EC // 748 ++ SYS_ISASCII = 0x2ED // 749 ++ SYS_TOASCII = 0x2EE // 750 ++ SYS_A64L = 0x2EF // 751 ++ SYS_L64A = 0x2F0 // 752 ++ SYS_UALARM = 0x2F1 // 753 ++ SYS_USLEEP = 0x2F2 // 754 ++ SYS___UTXTRM = 0x2F3 // 755 ++ SYS___SRCTRM = 0x2F4 // 756 ++ SYS_FTIME = 0x2F5 // 757 ++ SYS_GETTIMEOFDAY = 0x2F6 // 758 ++ SYS_DBM_CLEARERR = 0x2F7 // 759 ++ SYS_DBM_CLOSE = 0x2F8 // 760 ++ SYS_DBM_DELETE = 0x2F9 // 761 ++ SYS_DBM_ERROR = 0x2FA // 762 ++ SYS_DBM_FETCH = 0x2FB // 763 ++ SYS_DBM_FIRSTKEY = 0x2FC // 764 ++ SYS_DBM_NEXTKEY = 0x2FD // 765 ++ SYS_DBM_OPEN = 0x2FE // 766 ++ SYS_DBM_STORE = 0x2FF // 767 ++ SYS___NDMTRM = 0x300 // 768 ++ SYS_FTOK = 0x301 // 769 ++ SYS_BASENAME = 0x302 // 770 ++ SYS_DIRNAME = 0x303 // 771 ++ SYS_GETDTABLESIZE = 0x304 // 772 ++ SYS_MKSTEMP = 0x305 // 773 ++ SYS_MKTEMP = 0x306 // 774 ++ SYS_NFTW = 0x307 // 775 ++ SYS_GETWD = 0x308 // 776 ++ SYS_LOCKF = 0x309 // 777 ++ SYS__LONGJMP = 0x30D // 781 ++ SYS__SETJMP = 0x30E // 782 ++ SYS_VFORK = 0x30F // 783 ++ SYS_WORDEXP = 0x310 // 784 ++ SYS_WORDFREE = 0x311 // 785 ++ SYS_GETPGID = 0x312 // 786 ++ SYS_GETSID = 0x313 // 787 ++ SYS___UTMPXNAME = 0x314 // 788 ++ SYS_CUSERID = 0x315 // 789 ++ SYS_GETPASS = 0x316 // 790 ++ SYS_FNMATCH = 0x317 // 791 ++ SYS_FTW = 0x318 // 792 ++ SYS_GETW = 0x319 // 793 ++ SYS_GLOB = 0x31A // 794 ++ SYS_GLOBFREE = 0x31B // 795 ++ SYS_PUTW = 0x31C // 796 ++ SYS_SEEKDIR = 0x31D // 797 ++ SYS_TELLDIR = 0x31E // 798 ++ SYS_TEMPNAM = 0x31F // 799 ++ SYS_ACOSH = 0x320 // 800 ++ SYS_ASINH = 0x321 // 801 ++ SYS_ATANH = 0x322 // 802 ++ SYS_CBRT = 0x323 // 803 ++ SYS_EXPM1 = 0x324 // 804 ++ SYS_ILOGB = 0x325 // 805 ++ SYS_LOGB = 0x326 // 806 ++ SYS_LOG1P = 0x327 // 807 ++ SYS_NEXTAFTER = 0x328 // 808 ++ SYS_RINT = 0x329 // 809 ++ SYS_REMAINDER = 0x32A // 810 ++ SYS_SCALB = 0x32B // 811 ++ SYS_LGAMMA = 0x32C // 812 ++ SYS_TTYSLOT = 0x32D // 813 ++ SYS_GETTIMEOFDAY_R = 0x32E // 814 ++ SYS_SYNC = 0x32F // 815 ++ SYS_SPAWN = 0x330 // 816 ++ SYS_SPAWNP = 0x331 // 817 ++ SYS_GETLOGIN_UU = 0x332 // 818 ++ SYS_ECVT = 0x333 // 819 ++ SYS_FCVT = 0x334 // 820 ++ SYS_GCVT = 0x335 // 821 ++ SYS_ACCEPT = 0x336 // 822 ++ SYS_BIND = 0x337 // 823 ++ SYS_CONNECT = 0x338 // 824 ++ SYS_ENDHOSTENT = 0x339 // 825 ++ SYS_ENDPROTOENT = 0x33A // 826 ++ SYS_ENDSERVENT = 0x33B // 827 ++ SYS_GETHOSTBYADDR_R = 0x33C // 828 ++ SYS_GETHOSTBYADDR = 0x33D // 829 ++ SYS_GETHOSTBYNAME_R = 0x33E // 830 ++ SYS_GETHOSTBYNAME = 0x33F // 831 ++ SYS_GETHOSTENT = 0x340 // 832 ++ SYS_GETHOSTID = 0x341 // 833 ++ SYS_GETHOSTNAME = 0x342 // 834 ++ SYS_GETNETBYADDR = 0x343 // 835 ++ SYS_GETNETBYNAME = 0x344 // 836 ++ SYS_GETNETENT = 0x345 // 837 ++ SYS_GETPEERNAME = 0x346 // 838 ++ SYS_GETPROTOBYNAME = 0x347 // 839 ++ SYS_GETPROTOBYNUMBER = 0x348 // 840 ++ SYS_GETPROTOENT = 0x349 // 841 ++ SYS_GETSERVBYNAME = 0x34A // 842 ++ SYS_GETSERVBYPORT = 0x34B // 843 ++ SYS_GETSERVENT = 0x34C // 844 ++ SYS_GETSOCKNAME = 0x34D // 845 ++ SYS_GETSOCKOPT = 0x34E // 846 ++ SYS_INET_ADDR = 0x34F // 847 ++ SYS_INET_LNAOF = 0x350 // 848 ++ SYS_INET_MAKEADDR = 0x351 // 849 ++ SYS_INET_NETOF = 0x352 // 850 ++ SYS_INET_NETWORK = 0x353 // 851 ++ SYS_INET_NTOA = 0x354 // 852 ++ SYS_IOCTL = 0x355 // 853 ++ SYS_LISTEN = 0x356 // 854 ++ SYS_READV = 0x357 // 855 ++ SYS_RECV = 0x358 // 856 ++ SYS_RECVFROM = 0x359 // 857 ++ SYS_SELECT = 0x35B // 859 ++ SYS_SELECTEX = 0x35C // 860 ++ SYS_SEND = 0x35D // 861 ++ SYS_SENDTO = 0x35F // 863 ++ SYS_SETHOSTENT = 0x360 // 864 ++ SYS_SETNETENT = 0x361 // 865 ++ SYS_SETPEER = 0x362 // 866 ++ SYS_SETPROTOENT = 0x363 // 867 ++ SYS_SETSERVENT = 0x364 // 868 ++ SYS_SETSOCKOPT = 0x365 // 869 ++ SYS_SHUTDOWN = 0x366 // 870 ++ SYS_SOCKET = 0x367 // 871 ++ SYS_SOCKETPAIR = 0x368 // 872 ++ SYS_WRITEV = 0x369 // 873 ++ SYS_CHROOT = 0x36A // 874 ++ SYS_W_STATVFS = 0x36B // 875 ++ SYS_ULIMIT = 0x36C // 876 ++ SYS_ISNAN = 0x36D // 877 ++ SYS_UTIMES = 0x36E // 878 ++ SYS___H_ERRNO = 0x36F // 879 ++ SYS_ENDNETENT = 0x370 // 880 ++ SYS_CLOSELOG = 0x371 // 881 ++ SYS_OPENLOG = 0x372 // 882 ++ SYS_SETLOGMASK = 0x373 // 883 ++ SYS_SYSLOG = 0x374 // 884 ++ SYS_PTSNAME = 0x375 // 885 ++ SYS_SETREUID = 0x376 // 886 ++ SYS_SETREGID = 0x377 // 887 ++ SYS_REALPATH = 0x378 // 888 ++ SYS___SIGNGAM = 0x379 // 889 ++ SYS_GRANTPT = 0x37A // 890 ++ SYS_UNLOCKPT = 0x37B // 891 ++ SYS_TCGETSID = 0x37C // 892 ++ SYS___TCGETCP = 0x37D // 893 ++ SYS___TCSETCP = 0x37E // 894 ++ SYS___TCSETTABLES = 0x37F // 895 ++ SYS_POLL = 0x380 // 896 ++ SYS_REXEC = 0x381 // 897 ++ SYS___ISASCII2 = 0x382 // 898 ++ SYS___TOASCII2 = 0x383 // 899 ++ SYS_CHPRIORITY = 0x384 // 900 ++ SYS_PTHREAD_ATTR_SETSYNCTYPE_NP = 0x385 // 901 ++ SYS_PTHREAD_ATTR_GETSYNCTYPE_NP = 0x386 // 902 ++ SYS_PTHREAD_SET_LIMIT_NP = 0x387 // 903 ++ SYS___STNETENT = 0x388 // 904 ++ SYS___STPROTOENT = 0x389 // 905 ++ SYS___STSERVENT = 0x38A // 906 ++ SYS___STHOSTENT = 0x38B // 907 ++ SYS_NLIST = 0x38C // 908 ++ SYS___IPDBCS = 0x38D // 909 ++ SYS___IPDSPX = 0x38E // 910 ++ SYS___IPMSGC = 0x38F // 911 ++ SYS___SELECT1 = 0x390 // 912 ++ SYS_PTHREAD_SECURITY_NP = 0x391 // 913 ++ SYS___CHECK_RESOURCE_AUTH_NP = 0x392 // 914 ++ SYS___CONVERT_ID_NP = 0x393 // 915 ++ SYS___OPENVMREL = 0x394 // 916 ++ SYS_WMEMCHR = 0x395 // 917 ++ SYS_WMEMCMP = 0x396 // 918 ++ SYS_WMEMCPY = 0x397 // 919 ++ SYS_WMEMMOVE = 0x398 // 920 ++ SYS_WMEMSET = 0x399 // 921 ++ SYS___FPUTWC = 0x400 // 1024 ++ SYS___PUTWC = 0x401 // 1025 ++ SYS___PWCHAR = 0x402 // 1026 ++ SYS___WCSFTM = 0x403 // 1027 ++ SYS___WCSTOK = 0x404 // 1028 ++ SYS___WCWDTH = 0x405 // 1029 ++ SYS_T_ACCEPT = 0x409 // 1033 ++ SYS_T_ALLOC = 0x40A // 1034 ++ SYS_T_BIND = 0x40B // 1035 ++ SYS_T_CLOSE = 0x40C // 1036 ++ SYS_T_CONNECT = 0x40D // 1037 ++ SYS_T_ERROR = 0x40E // 1038 ++ SYS_T_FREE = 0x40F // 1039 ++ SYS_T_GETINFO = 0x410 // 1040 ++ SYS_T_GETPROTADDR = 0x411 // 1041 ++ SYS_T_GETSTATE = 0x412 // 1042 ++ SYS_T_LISTEN = 0x413 // 1043 ++ SYS_T_LOOK = 0x414 // 1044 ++ SYS_T_OPEN = 0x415 // 1045 ++ SYS_T_OPTMGMT = 0x416 // 1046 ++ SYS_T_RCV = 0x417 // 1047 ++ SYS_T_RCVCONNECT = 0x418 // 1048 ++ SYS_T_RCVDIS = 0x419 // 1049 ++ SYS_T_RCVREL = 0x41A // 1050 ++ SYS_T_RCVUDATA = 0x41B // 1051 ++ SYS_T_RCVUDERR = 0x41C // 1052 ++ SYS_T_SND = 0x41D // 1053 ++ SYS_T_SNDDIS = 0x41E // 1054 ++ SYS_T_SNDREL = 0x41F // 1055 ++ SYS_T_SNDUDATA = 0x420 // 1056 ++ SYS_T_STRERROR = 0x421 // 1057 ++ SYS_T_SYNC = 0x422 // 1058 ++ SYS_T_UNBIND = 0x423 // 1059 ++ SYS___T_ERRNO = 0x424 // 1060 ++ SYS___RECVMSG2 = 0x425 // 1061 ++ SYS___SENDMSG2 = 0x426 // 1062 ++ SYS_FATTACH = 0x427 // 1063 ++ SYS_FDETACH = 0x428 // 1064 ++ SYS_GETMSG = 0x429 // 1065 ++ SYS_GETPMSG = 0x42A // 1066 ++ SYS_ISASTREAM = 0x42B // 1067 ++ SYS_PUTMSG = 0x42C // 1068 ++ SYS_PUTPMSG = 0x42D // 1069 ++ SYS___ISPOSIXON = 0x42E // 1070 ++ SYS___OPENMVSREL = 0x42F // 1071 ++ SYS_GETCONTEXT = 0x430 // 1072 ++ SYS_SETCONTEXT = 0x431 // 1073 ++ SYS_MAKECONTEXT = 0x432 // 1074 ++ SYS_SWAPCONTEXT = 0x433 // 1075 ++ SYS_PTHREAD_GETSPECIFIC_D8_NP = 0x434 // 1076 ++ SYS_GETCLIENTID = 0x470 // 1136 ++ SYS___GETCLIENTID = 0x471 // 1137 ++ SYS_GETSTABLESIZE = 0x472 // 1138 ++ SYS_GETIBMOPT = 0x473 // 1139 ++ SYS_GETIBMSOCKOPT = 0x474 // 1140 ++ SYS_GIVESOCKET = 0x475 // 1141 ++ SYS_IBMSFLUSH = 0x476 // 1142 ++ SYS_MAXDESC = 0x477 // 1143 ++ SYS_SETIBMOPT = 0x478 // 1144 ++ SYS_SETIBMSOCKOPT = 0x479 // 1145 ++ SYS_SOCK_DEBUG = 0x47A // 1146 ++ SYS_SOCK_DO_TESTSTOR = 0x47D // 1149 ++ SYS_TAKESOCKET = 0x47E // 1150 ++ SYS___SERVER_INIT = 0x47F // 1151 ++ SYS___SERVER_PWU = 0x480 // 1152 ++ SYS_PTHREAD_TAG_NP = 0x481 // 1153 ++ SYS___CONSOLE = 0x482 // 1154 ++ SYS___WSINIT = 0x483 // 1155 ++ SYS___IPTCPN = 0x489 // 1161 ++ SYS___SMF_RECORD = 0x48A // 1162 ++ SYS___IPHOST = 0x48B // 1163 ++ SYS___IPNODE = 0x48C // 1164 ++ SYS___SERVER_CLASSIFY_CREATE = 0x48D // 1165 ++ SYS___SERVER_CLASSIFY_DESTROY = 0x48E // 1166 ++ SYS___SERVER_CLASSIFY_RESET = 0x48F // 1167 ++ SYS___SERVER_CLASSIFY = 0x490 // 1168 ++ SYS___HEAPRPT = 0x496 // 1174 ++ SYS___FNWSA = 0x49B // 1179 ++ SYS___SPAWN2 = 0x49D // 1181 ++ SYS___SPAWNP2 = 0x49E // 1182 ++ SYS___GDRR = 0x4A1 // 1185 ++ SYS___HRRNO = 0x4A2 // 1186 ++ SYS___OPRG = 0x4A3 // 1187 ++ SYS___OPRR = 0x4A4 // 1188 ++ SYS___OPND = 0x4A5 // 1189 ++ SYS___OPPT = 0x4A6 // 1190 ++ SYS___SIGGM = 0x4A7 // 1191 ++ SYS___DGHT = 0x4A8 // 1192 ++ SYS___TZNE = 0x4A9 // 1193 ++ SYS___TZZN = 0x4AA // 1194 ++ SYS___TRRNO = 0x4AF // 1199 ++ SYS___ENVN = 0x4B0 // 1200 ++ SYS___MLOCKALL = 0x4B1 // 1201 ++ SYS_CREATEWO = 0x4B2 // 1202 ++ SYS_CREATEWORKUNIT = 0x4B2 // 1202 ++ SYS_CONTINUE = 0x4B3 // 1203 ++ SYS_CONTINUEWORKUNIT = 0x4B3 // 1203 ++ SYS_CONNECTW = 0x4B4 // 1204 ++ SYS_CONNECTWORKMGR = 0x4B4 // 1204 ++ SYS_CONNECTS = 0x4B5 // 1205 ++ SYS_CONNECTSERVER = 0x4B5 // 1205 ++ SYS_DISCONNE = 0x4B6 // 1206 ++ SYS_DISCONNECTSERVER = 0x4B6 // 1206 ++ SYS_JOINWORK = 0x4B7 // 1207 ++ SYS_JOINWORKUNIT = 0x4B7 // 1207 ++ SYS_LEAVEWOR = 0x4B8 // 1208 ++ SYS_LEAVEWORKUNIT = 0x4B8 // 1208 ++ SYS_DELETEWO = 0x4B9 // 1209 ++ SYS_DELETEWORKUNIT = 0x4B9 // 1209 ++ SYS_QUERYMET = 0x4BA // 1210 ++ SYS_QUERYMETRICS = 0x4BA // 1210 ++ SYS_QUERYSCH = 0x4BB // 1211 ++ SYS_QUERYSCHENV = 0x4BB // 1211 ++ SYS_CHECKSCH = 0x4BC // 1212 ++ SYS_CHECKSCHENV = 0x4BC // 1212 ++ SYS___PID_AFFINITY = 0x4BD // 1213 ++ SYS___ASINH_B = 0x4BE // 1214 ++ SYS___ATAN_B = 0x4BF // 1215 ++ SYS___CBRT_B = 0x4C0 // 1216 ++ SYS___CEIL_B = 0x4C1 // 1217 ++ SYS_COPYSIGN = 0x4C2 // 1218 ++ SYS___COS_B = 0x4C3 // 1219 ++ SYS___ERF_B = 0x4C4 // 1220 ++ SYS___ERFC_B = 0x4C5 // 1221 ++ SYS___EXPM1_B = 0x4C6 // 1222 ++ SYS___FABS_B = 0x4C7 // 1223 ++ SYS_FINITE = 0x4C8 // 1224 ++ SYS___FLOOR_B = 0x4C9 // 1225 ++ SYS___FREXP_B = 0x4CA // 1226 ++ SYS___ILOGB_B = 0x4CB // 1227 ++ SYS___ISNAN_B = 0x4CC // 1228 ++ SYS___LDEXP_B = 0x4CD // 1229 ++ SYS___LOG1P_B = 0x4CE // 1230 ++ SYS___LOGB_B = 0x4CF // 1231 ++ SYS_MATHERR = 0x4D0 // 1232 ++ SYS___MODF_B = 0x4D1 // 1233 ++ SYS___NEXTAFTER_B = 0x4D2 // 1234 ++ SYS___RINT_B = 0x4D3 // 1235 ++ SYS_SCALBN = 0x4D4 // 1236 ++ SYS_SIGNIFIC = 0x4D5 // 1237 ++ SYS_SIGNIFICAND = 0x4D5 // 1237 ++ SYS___SIN_B = 0x4D6 // 1238 ++ SYS___TAN_B = 0x4D7 // 1239 ++ SYS___TANH_B = 0x4D8 // 1240 ++ SYS___ACOS_B = 0x4D9 // 1241 ++ SYS___ACOSH_B = 0x4DA // 1242 ++ SYS___ASIN_B = 0x4DB // 1243 ++ SYS___ATAN2_B = 0x4DC // 1244 ++ SYS___ATANH_B = 0x4DD // 1245 ++ SYS___COSH_B = 0x4DE // 1246 ++ SYS___EXP_B = 0x4DF // 1247 ++ SYS___FMOD_B = 0x4E0 // 1248 ++ SYS___GAMMA_B = 0x4E1 // 1249 ++ SYS_GAMMA_R = 0x4E2 // 1250 ++ SYS___HYPOT_B = 0x4E3 // 1251 ++ SYS___J0_B = 0x4E4 // 1252 ++ SYS___Y0_B = 0x4E5 // 1253 ++ SYS___J1_B = 0x4E6 // 1254 ++ SYS___Y1_B = 0x4E7 // 1255 ++ SYS___JN_B = 0x4E8 // 1256 ++ SYS___YN_B = 0x4E9 // 1257 ++ SYS___LGAMMA_B = 0x4EA // 1258 ++ SYS_LGAMMA_R = 0x4EB // 1259 ++ SYS___LOG_B = 0x4EC // 1260 ++ SYS___LOG10_B = 0x4ED // 1261 ++ SYS___POW_B = 0x4EE // 1262 ++ SYS___REMAINDER_B = 0x4EF // 1263 ++ SYS___SCALB_B = 0x4F0 // 1264 ++ SYS___SINH_B = 0x4F1 // 1265 ++ SYS___SQRT_B = 0x4F2 // 1266 ++ SYS___OPENDIR2 = 0x4F3 // 1267 ++ SYS___READDIR2 = 0x4F4 // 1268 ++ SYS___LOGIN = 0x4F5 // 1269 ++ SYS___OPEN_STAT = 0x4F6 // 1270 ++ SYS_ACCEPT_AND_RECV = 0x4F7 // 1271 ++ SYS___FP_SETMODE = 0x4F8 // 1272 ++ SYS___SIGACTIONSET = 0x4FB // 1275 ++ SYS___UCREATE = 0x4FC // 1276 ++ SYS___UMALLOC = 0x4FD // 1277 ++ SYS___UFREE = 0x4FE // 1278 ++ SYS___UHEAPREPORT = 0x4FF // 1279 ++ SYS___ISBFP = 0x500 // 1280 ++ SYS___FP_CAST = 0x501 // 1281 ++ SYS___CERTIFICATE = 0x502 // 1282 ++ SYS_SEND_FILE = 0x503 // 1283 ++ SYS_AIO_CANCEL = 0x504 // 1284 ++ SYS_AIO_ERROR = 0x505 // 1285 ++ SYS_AIO_READ = 0x506 // 1286 ++ SYS_AIO_RETURN = 0x507 // 1287 ++ SYS_AIO_SUSPEND = 0x508 // 1288 ++ SYS_AIO_WRITE = 0x509 // 1289 ++ SYS_PTHREAD_MUTEXATTR_GETPSHARED = 0x50A // 1290 ++ SYS_PTHREAD_MUTEXATTR_SETPSHARED = 0x50B // 1291 ++ SYS_PTHREAD_RWLOCK_DESTROY = 0x50C // 1292 ++ SYS_PTHREAD_RWLOCK_INIT = 0x50D // 1293 ++ SYS_PTHREAD_RWLOCK_RDLOCK = 0x50E // 1294 ++ SYS_PTHREAD_RWLOCK_TRYRDLOCK = 0x50F // 1295 ++ SYS_PTHREAD_RWLOCK_TRYWRLOCK = 0x510 // 1296 ++ SYS_PTHREAD_RWLOCK_UNLOCK = 0x511 // 1297 ++ SYS_PTHREAD_RWLOCK_WRLOCK = 0x512 // 1298 ++ SYS_PTHREAD_RWLOCKATTR_GETPSHARED = 0x513 // 1299 ++ SYS_PTHREAD_RWLOCKATTR_SETPSHARED = 0x514 // 1300 ++ SYS_PTHREAD_RWLOCKATTR_INIT = 0x515 // 1301 ++ SYS_PTHREAD_RWLOCKATTR_DESTROY = 0x516 // 1302 ++ SYS___CTTBL = 0x517 // 1303 ++ SYS_PTHREAD_MUTEXATTR_SETTYPE = 0x518 // 1304 ++ SYS_PTHREAD_MUTEXATTR_GETTYPE = 0x519 // 1305 ++ SYS___FP_CLR_FLAG = 0x51A // 1306 ++ SYS___FP_READ_FLAG = 0x51B // 1307 ++ SYS___FP_RAISE_XCP = 0x51C // 1308 ++ SYS___FP_CLASS = 0x51D // 1309 ++ SYS___FP_FINITE = 0x51E // 1310 ++ SYS___FP_ISNAN = 0x51F // 1311 ++ SYS___FP_UNORDERED = 0x520 // 1312 ++ SYS___FP_READ_RND = 0x521 // 1313 ++ SYS___FP_READ_RND_B = 0x522 // 1314 ++ SYS___FP_SWAP_RND = 0x523 // 1315 ++ SYS___FP_SWAP_RND_B = 0x524 // 1316 ++ SYS___FP_LEVEL = 0x525 // 1317 ++ SYS___FP_BTOH = 0x526 // 1318 ++ SYS___FP_HTOB = 0x527 // 1319 ++ SYS___FPC_RD = 0x528 // 1320 ++ SYS___FPC_WR = 0x529 // 1321 ++ SYS___FPC_RW = 0x52A // 1322 ++ SYS___FPC_SM = 0x52B // 1323 ++ SYS___FPC_RS = 0x52C // 1324 ++ SYS_SIGTIMEDWAIT = 0x52D // 1325 ++ SYS_SIGWAITINFO = 0x52E // 1326 ++ SYS___CHKBFP = 0x52F // 1327 ++ SYS___W_PIOCTL = 0x59E // 1438 ++ SYS___OSENV = 0x59F // 1439 ++ SYS_EXPORTWO = 0x5A1 // 1441 ++ SYS_EXPORTWORKUNIT = 0x5A1 // 1441 ++ SYS_UNDOEXPO = 0x5A2 // 1442 ++ SYS_UNDOEXPORTWORKUNIT = 0x5A2 // 1442 ++ SYS_IMPORTWO = 0x5A3 // 1443 ++ SYS_IMPORTWORKUNIT = 0x5A3 // 1443 ++ SYS_UNDOIMPO = 0x5A4 // 1444 ++ SYS_UNDOIMPORTWORKUNIT = 0x5A4 // 1444 ++ SYS_EXTRACTW = 0x5A5 // 1445 ++ SYS_EXTRACTWORKUNIT = 0x5A5 // 1445 ++ SYS___CPL = 0x5A6 // 1446 ++ SYS___MAP_INIT = 0x5A7 // 1447 ++ SYS___MAP_SERVICE = 0x5A8 // 1448 ++ SYS_SIGQUEUE = 0x5A9 // 1449 ++ SYS___MOUNT = 0x5AA // 1450 ++ SYS___GETUSERID = 0x5AB // 1451 ++ SYS___IPDOMAINNAME = 0x5AC // 1452 ++ SYS_QUERYENC = 0x5AD // 1453 ++ SYS_QUERYWORKUNITCLASSIFICATION = 0x5AD // 1453 ++ SYS_CONNECTE = 0x5AE // 1454 ++ SYS_CONNECTEXPORTIMPORT = 0x5AE // 1454 ++ SYS___FP_SWAPMODE = 0x5AF // 1455 ++ SYS_STRTOLL = 0x5B0 // 1456 ++ SYS_STRTOULL = 0x5B1 // 1457 ++ SYS___DSA_PREV = 0x5B2 // 1458 ++ SYS___EP_FIND = 0x5B3 // 1459 ++ SYS___SERVER_THREADS_QUERY = 0x5B4 // 1460 ++ SYS___MSGRCV_TIMED = 0x5B7 // 1463 ++ SYS___SEMOP_TIMED = 0x5B8 // 1464 ++ SYS___GET_CPUID = 0x5B9 // 1465 ++ SYS___GET_SYSTEM_SETTINGS = 0x5BA // 1466 ++ SYS_FTELLO = 0x5C8 // 1480 ++ SYS_FSEEKO = 0x5C9 // 1481 ++ SYS_LLDIV = 0x5CB // 1483 ++ SYS_WCSTOLL = 0x5CC // 1484 ++ SYS_WCSTOULL = 0x5CD // 1485 ++ SYS_LLABS = 0x5CE // 1486 ++ SYS___CONSOLE2 = 0x5D2 // 1490 ++ SYS_INET_NTOP = 0x5D3 // 1491 ++ SYS_INET_PTON = 0x5D4 // 1492 ++ SYS___RES = 0x5D6 // 1494 ++ SYS_RES_MKQUERY = 0x5D7 // 1495 ++ SYS_RES_INIT = 0x5D8 // 1496 ++ SYS_RES_QUERY = 0x5D9 // 1497 ++ SYS_RES_SEARCH = 0x5DA // 1498 ++ SYS_RES_SEND = 0x5DB // 1499 ++ SYS_RES_QUERYDOMAIN = 0x5DC // 1500 ++ SYS_DN_EXPAND = 0x5DD // 1501 ++ SYS_DN_SKIPNAME = 0x5DE // 1502 ++ SYS_DN_COMP = 0x5DF // 1503 ++ SYS_ASCTIME_R = 0x5E0 // 1504 ++ SYS_CTIME_R = 0x5E1 // 1505 ++ SYS_GMTIME_R = 0x5E2 // 1506 ++ SYS_LOCALTIME_R = 0x5E3 // 1507 ++ SYS_RAND_R = 0x5E4 // 1508 ++ SYS_STRTOK_R = 0x5E5 // 1509 ++ SYS_READDIR_R = 0x5E6 // 1510 ++ SYS_GETGRGID_R = 0x5E7 // 1511 ++ SYS_GETGRNAM_R = 0x5E8 // 1512 ++ SYS_GETLOGIN_R = 0x5E9 // 1513 ++ SYS_GETPWNAM_R = 0x5EA // 1514 ++ SYS_GETPWUID_R = 0x5EB // 1515 ++ SYS_TTYNAME_R = 0x5EC // 1516 ++ SYS_PTHREAD_ATFORK = 0x5ED // 1517 ++ SYS_PTHREAD_ATTR_GETGUARDSIZE = 0x5EE // 1518 ++ SYS_PTHREAD_ATTR_GETSTACKADDR = 0x5EF // 1519 ++ SYS_PTHREAD_ATTR_SETGUARDSIZE = 0x5F0 // 1520 ++ SYS_PTHREAD_ATTR_SETSTACKADDR = 0x5F1 // 1521 ++ SYS_PTHREAD_CONDATTR_GETPSHARED = 0x5F2 // 1522 ++ SYS_PTHREAD_CONDATTR_SETPSHARED = 0x5F3 // 1523 ++ SYS_PTHREAD_GETCONCURRENCY = 0x5F4 // 1524 ++ SYS_PTHREAD_KEY_DELETE = 0x5F5 // 1525 ++ SYS_PTHREAD_SETCONCURRENCY = 0x5F6 // 1526 ++ SYS_PTHREAD_SIGMASK = 0x5F7 // 1527 ++ SYS___DISCARDDATA = 0x5F8 // 1528 ++ SYS_PTHREAD_ATTR_GETSCHEDPARAM = 0x5F9 // 1529 ++ SYS_PTHREAD_ATTR_SETSCHEDPARAM = 0x5FA // 1530 ++ SYS_PTHREAD_ATTR_GETDETACHSTATE_U98 = 0x5FB // 1531 ++ SYS_PTHREAD_ATTR_SETDETACHSTATE_U98 = 0x5FC // 1532 ++ SYS_PTHREAD_DETACH_U98 = 0x5FD // 1533 ++ SYS_PTHREAD_GETSPECIFIC_U98 = 0x5FE // 1534 ++ SYS_PTHREAD_SETCANCELSTATE = 0x5FF // 1535 ++ SYS_PTHREAD_SETCANCELTYPE = 0x600 // 1536 ++ SYS_PTHREAD_TESTCANCEL = 0x601 // 1537 ++ SYS___ATANF_B = 0x602 // 1538 ++ SYS___ATANL_B = 0x603 // 1539 ++ SYS___CEILF_B = 0x604 // 1540 ++ SYS___CEILL_B = 0x605 // 1541 ++ SYS___COSF_B = 0x606 // 1542 ++ SYS___COSL_B = 0x607 // 1543 ++ SYS___FABSF_B = 0x608 // 1544 ++ SYS___FABSL_B = 0x609 // 1545 ++ SYS___FLOORF_B = 0x60A // 1546 ++ SYS___FLOORL_B = 0x60B // 1547 ++ SYS___FREXPF_B = 0x60C // 1548 ++ SYS___FREXPL_B = 0x60D // 1549 ++ SYS___LDEXPF_B = 0x60E // 1550 ++ SYS___LDEXPL_B = 0x60F // 1551 ++ SYS___SINF_B = 0x610 // 1552 ++ SYS___SINL_B = 0x611 // 1553 ++ SYS___TANF_B = 0x612 // 1554 ++ SYS___TANL_B = 0x613 // 1555 ++ SYS___TANHF_B = 0x614 // 1556 ++ SYS___TANHL_B = 0x615 // 1557 ++ SYS___ACOSF_B = 0x616 // 1558 ++ SYS___ACOSL_B = 0x617 // 1559 ++ SYS___ASINF_B = 0x618 // 1560 ++ SYS___ASINL_B = 0x619 // 1561 ++ SYS___ATAN2F_B = 0x61A // 1562 ++ SYS___ATAN2L_B = 0x61B // 1563 ++ SYS___COSHF_B = 0x61C // 1564 ++ SYS___COSHL_B = 0x61D // 1565 ++ SYS___EXPF_B = 0x61E // 1566 ++ SYS___EXPL_B = 0x61F // 1567 ++ SYS___LOGF_B = 0x620 // 1568 ++ SYS___LOGL_B = 0x621 // 1569 ++ SYS___LOG10F_B = 0x622 // 1570 ++ SYS___LOG10L_B = 0x623 // 1571 ++ SYS___POWF_B = 0x624 // 1572 ++ SYS___POWL_B = 0x625 // 1573 ++ SYS___SINHF_B = 0x626 // 1574 ++ SYS___SINHL_B = 0x627 // 1575 ++ SYS___SQRTF_B = 0x628 // 1576 ++ SYS___SQRTL_B = 0x629 // 1577 ++ SYS___ABSF_B = 0x62A // 1578 ++ SYS___ABS_B = 0x62B // 1579 ++ SYS___ABSL_B = 0x62C // 1580 ++ SYS___FMODF_B = 0x62D // 1581 ++ SYS___FMODL_B = 0x62E // 1582 ++ SYS___MODFF_B = 0x62F // 1583 ++ SYS___MODFL_B = 0x630 // 1584 ++ SYS_ABSF = 0x631 // 1585 ++ SYS_ABSL = 0x632 // 1586 ++ SYS_ACOSF = 0x633 // 1587 ++ SYS_ACOSL = 0x634 // 1588 ++ SYS_ASINF = 0x635 // 1589 ++ SYS_ASINL = 0x636 // 1590 ++ SYS_ATAN2F = 0x637 // 1591 ++ SYS_ATAN2L = 0x638 // 1592 ++ SYS_ATANF = 0x639 // 1593 ++ SYS_ATANL = 0x63A // 1594 ++ SYS_CEILF = 0x63B // 1595 ++ SYS_CEILL = 0x63C // 1596 ++ SYS_COSF = 0x63D // 1597 ++ SYS_COSL = 0x63E // 1598 ++ SYS_COSHF = 0x63F // 1599 ++ SYS_COSHL = 0x640 // 1600 ++ SYS_EXPF = 0x641 // 1601 ++ SYS_EXPL = 0x642 // 1602 ++ SYS_TANHF = 0x643 // 1603 ++ SYS_TANHL = 0x644 // 1604 ++ SYS_LOG10F = 0x645 // 1605 ++ SYS_LOG10L = 0x646 // 1606 ++ SYS_LOGF = 0x647 // 1607 ++ SYS_LOGL = 0x648 // 1608 ++ SYS_POWF = 0x649 // 1609 ++ SYS_POWL = 0x64A // 1610 ++ SYS_SINF = 0x64B // 1611 ++ SYS_SINL = 0x64C // 1612 ++ SYS_SQRTF = 0x64D // 1613 ++ SYS_SQRTL = 0x64E // 1614 ++ SYS_SINHF = 0x64F // 1615 ++ SYS_SINHL = 0x650 // 1616 ++ SYS_TANF = 0x651 // 1617 ++ SYS_TANL = 0x652 // 1618 ++ SYS_FABSF = 0x653 // 1619 ++ SYS_FABSL = 0x654 // 1620 ++ SYS_FLOORF = 0x655 // 1621 ++ SYS_FLOORL = 0x656 // 1622 ++ SYS_FMODF = 0x657 // 1623 ++ SYS_FMODL = 0x658 // 1624 ++ SYS_FREXPF = 0x659 // 1625 ++ SYS_FREXPL = 0x65A // 1626 ++ SYS_LDEXPF = 0x65B // 1627 ++ SYS_LDEXPL = 0x65C // 1628 ++ SYS_MODFF = 0x65D // 1629 ++ SYS_MODFL = 0x65E // 1630 ++ SYS_BTOWC = 0x65F // 1631 ++ SYS___CHATTR = 0x660 // 1632 ++ SYS___FCHATTR = 0x661 // 1633 ++ SYS___TOCCSID = 0x662 // 1634 ++ SYS___CSNAMETYPE = 0x663 // 1635 ++ SYS___TOCSNAME = 0x664 // 1636 ++ SYS___CCSIDTYPE = 0x665 // 1637 ++ SYS___AE_CORRESTBL_QUERY = 0x666 // 1638 ++ SYS___AE_AUTOCONVERT_STATE = 0x667 // 1639 ++ SYS_DN_FIND = 0x668 // 1640 ++ SYS___GETHOSTBYADDR_A = 0x669 // 1641 ++ SYS___GETHOSTBYNAME_A = 0x66A // 1642 ++ SYS___RES_INIT_A = 0x66B // 1643 ++ SYS___GETHOSTBYADDR_R_A = 0x66C // 1644 ++ SYS___GETHOSTBYNAME_R_A = 0x66D // 1645 ++ SYS___CHARMAP_INIT_A = 0x66E // 1646 ++ SYS___MBLEN_A = 0x66F // 1647 ++ SYS___MBLEN_SB_A = 0x670 // 1648 ++ SYS___MBLEN_STD_A = 0x671 // 1649 ++ SYS___MBLEN_UTF = 0x672 // 1650 ++ SYS___MBSTOWCS_A = 0x673 // 1651 ++ SYS___MBSTOWCS_STD_A = 0x674 // 1652 ++ SYS___MBTOWC_A = 0x675 // 1653 ++ SYS___MBTOWC_ISO1 = 0x676 // 1654 ++ SYS___MBTOWC_SBCS = 0x677 // 1655 ++ SYS___MBTOWC_MBCS = 0x678 // 1656 ++ SYS___MBTOWC_UTF = 0x679 // 1657 ++ SYS___WCSTOMBS_A = 0x67A // 1658 ++ SYS___WCSTOMBS_STD_A = 0x67B // 1659 ++ SYS___WCSWIDTH_A = 0x67C // 1660 ++ SYS___GETGRGID_R_A = 0x67D // 1661 ++ SYS___WCSWIDTH_STD_A = 0x67E // 1662 ++ SYS___WCSWIDTH_ASIA = 0x67F // 1663 ++ SYS___CSID_A = 0x680 // 1664 ++ SYS___CSID_STD_A = 0x681 // 1665 ++ SYS___WCSID_A = 0x682 // 1666 ++ SYS___WCSID_STD_A = 0x683 // 1667 ++ SYS___WCTOMB_A = 0x684 // 1668 ++ SYS___WCTOMB_ISO1 = 0x685 // 1669 ++ SYS___WCTOMB_STD_A = 0x686 // 1670 ++ SYS___WCTOMB_UTF = 0x687 // 1671 ++ SYS___WCWIDTH_A = 0x688 // 1672 ++ SYS___GETGRNAM_R_A = 0x689 // 1673 ++ SYS___WCWIDTH_STD_A = 0x68A // 1674 ++ SYS___WCWIDTH_ASIA = 0x68B // 1675 ++ SYS___GETPWNAM_R_A = 0x68C // 1676 ++ SYS___GETPWUID_R_A = 0x68D // 1677 ++ SYS___GETLOGIN_R_A = 0x68E // 1678 ++ SYS___TTYNAME_R_A = 0x68F // 1679 ++ SYS___READDIR_R_A = 0x690 // 1680 ++ SYS___E2A_S = 0x691 // 1681 ++ SYS___FNMATCH_A = 0x692 // 1682 ++ SYS___FNMATCH_C_A = 0x693 // 1683 ++ SYS___EXECL_A = 0x694 // 1684 ++ SYS___FNMATCH_STD_A = 0x695 // 1685 ++ SYS___REGCOMP_A = 0x696 // 1686 ++ SYS___REGCOMP_STD_A = 0x697 // 1687 ++ SYS___REGERROR_A = 0x698 // 1688 ++ SYS___REGERROR_STD_A = 0x699 // 1689 ++ SYS___REGEXEC_A = 0x69A // 1690 ++ SYS___REGEXEC_STD_A = 0x69B // 1691 ++ SYS___REGFREE_A = 0x69C // 1692 ++ SYS___REGFREE_STD_A = 0x69D // 1693 ++ SYS___STRCOLL_A = 0x69E // 1694 ++ SYS___STRCOLL_C_A = 0x69F // 1695 ++ SYS___EXECLE_A = 0x6A0 // 1696 ++ SYS___STRCOLL_STD_A = 0x6A1 // 1697 ++ SYS___STRXFRM_A = 0x6A2 // 1698 ++ SYS___STRXFRM_C_A = 0x6A3 // 1699 ++ SYS___EXECLP_A = 0x6A4 // 1700 ++ SYS___STRXFRM_STD_A = 0x6A5 // 1701 ++ SYS___WCSCOLL_A = 0x6A6 // 1702 ++ SYS___WCSCOLL_C_A = 0x6A7 // 1703 ++ SYS___WCSCOLL_STD_A = 0x6A8 // 1704 ++ SYS___WCSXFRM_A = 0x6A9 // 1705 ++ SYS___WCSXFRM_C_A = 0x6AA // 1706 ++ SYS___WCSXFRM_STD_A = 0x6AB // 1707 ++ SYS___COLLATE_INIT_A = 0x6AC // 1708 ++ SYS___WCTYPE_A = 0x6AD // 1709 ++ SYS___GET_WCTYPE_STD_A = 0x6AE // 1710 ++ SYS___CTYPE_INIT_A = 0x6AF // 1711 ++ SYS___ISWCTYPE_A = 0x6B0 // 1712 ++ SYS___EXECV_A = 0x6B1 // 1713 ++ SYS___IS_WCTYPE_STD_A = 0x6B2 // 1714 ++ SYS___TOWLOWER_A = 0x6B3 // 1715 ++ SYS___TOWLOWER_STD_A = 0x6B4 // 1716 ++ SYS___TOWUPPER_A = 0x6B5 // 1717 ++ SYS___TOWUPPER_STD_A = 0x6B6 // 1718 ++ SYS___LOCALE_INIT_A = 0x6B7 // 1719 ++ SYS___LOCALECONV_A = 0x6B8 // 1720 ++ SYS___LOCALECONV_STD_A = 0x6B9 // 1721 ++ SYS___NL_LANGINFO_A = 0x6BA // 1722 ++ SYS___NL_LNAGINFO_STD_A = 0x6BB // 1723 ++ SYS___MONETARY_INIT_A = 0x6BC // 1724 ++ SYS___STRFMON_A = 0x6BD // 1725 ++ SYS___STRFMON_STD_A = 0x6BE // 1726 ++ SYS___GETADDRINFO_A = 0x6BF // 1727 ++ SYS___CATGETS_A = 0x6C0 // 1728 ++ SYS___EXECVE_A = 0x6C1 // 1729 ++ SYS___EXECVP_A = 0x6C2 // 1730 ++ SYS___SPAWN_A = 0x6C3 // 1731 ++ SYS___GETNAMEINFO_A = 0x6C4 // 1732 ++ SYS___SPAWNP_A = 0x6C5 // 1733 ++ SYS___NUMERIC_INIT_A = 0x6C6 // 1734 ++ SYS___RESP_INIT_A = 0x6C7 // 1735 ++ SYS___RPMATCH_A = 0x6C8 // 1736 ++ SYS___RPMATCH_C_A = 0x6C9 // 1737 ++ SYS___RPMATCH_STD_A = 0x6CA // 1738 ++ SYS___TIME_INIT_A = 0x6CB // 1739 ++ SYS___STRFTIME_A = 0x6CC // 1740 ++ SYS___STRFTIME_STD_A = 0x6CD // 1741 ++ SYS___STRPTIME_A = 0x6CE // 1742 ++ SYS___STRPTIME_STD_A = 0x6CF // 1743 ++ SYS___WCSFTIME_A = 0x6D0 // 1744 ++ SYS___WCSFTIME_STD_A = 0x6D1 // 1745 ++ SYS_____SPAWN2_A = 0x6D2 // 1746 ++ SYS_____SPAWNP2_A = 0x6D3 // 1747 ++ SYS___SYNTAX_INIT_A = 0x6D4 // 1748 ++ SYS___TOD_INIT_A = 0x6D5 // 1749 ++ SYS___NL_CSINFO_A = 0x6D6 // 1750 ++ SYS___NL_MONINFO_A = 0x6D7 // 1751 ++ SYS___NL_NUMINFO_A = 0x6D8 // 1752 ++ SYS___NL_RESPINFO_A = 0x6D9 // 1753 ++ SYS___NL_TIMINFO_A = 0x6DA // 1754 ++ SYS___IF_NAMETOINDEX_A = 0x6DB // 1755 ++ SYS___IF_INDEXTONAME_A = 0x6DC // 1756 ++ SYS___PRINTF_A = 0x6DD // 1757 ++ SYS___ICONV_OPEN_A = 0x6DE // 1758 ++ SYS___DLLLOAD_A = 0x6DF // 1759 ++ SYS___DLLQUERYFN_A = 0x6E0 // 1760 ++ SYS___DLLQUERYVAR_A = 0x6E1 // 1761 ++ SYS_____CHATTR_A = 0x6E2 // 1762 ++ SYS___E2A_L = 0x6E3 // 1763 ++ SYS_____TOCCSID_A = 0x6E4 // 1764 ++ SYS_____TOCSNAME_A = 0x6E5 // 1765 ++ SYS_____CCSIDTYPE_A = 0x6E6 // 1766 ++ SYS_____CSNAMETYPE_A = 0x6E7 // 1767 ++ SYS___CHMOD_A = 0x6E8 // 1768 ++ SYS___MKDIR_A = 0x6E9 // 1769 ++ SYS___STAT_A = 0x6EA // 1770 ++ SYS___STAT_O_A = 0x6EB // 1771 ++ SYS___MKFIFO_A = 0x6EC // 1772 ++ SYS_____OPEN_STAT_A = 0x6ED // 1773 ++ SYS___LSTAT_A = 0x6EE // 1774 ++ SYS___LSTAT_O_A = 0x6EF // 1775 ++ SYS___MKNOD_A = 0x6F0 // 1776 ++ SYS___MOUNT_A = 0x6F1 // 1777 ++ SYS___UMOUNT_A = 0x6F2 // 1778 ++ SYS___CHAUDIT_A = 0x6F4 // 1780 ++ SYS___W_GETMNTENT_A = 0x6F5 // 1781 ++ SYS___CREAT_A = 0x6F6 // 1782 ++ SYS___OPEN_A = 0x6F7 // 1783 ++ SYS___SETLOCALE_A = 0x6F9 // 1785 ++ SYS___FPRINTF_A = 0x6FA // 1786 ++ SYS___SPRINTF_A = 0x6FB // 1787 ++ SYS___VFPRINTF_A = 0x6FC // 1788 ++ SYS___VPRINTF_A = 0x6FD // 1789 ++ SYS___VSPRINTF_A = 0x6FE // 1790 ++ SYS___VSWPRINTF_A = 0x6FF // 1791 ++ SYS___SWPRINTF_A = 0x700 // 1792 ++ SYS___FSCANF_A = 0x701 // 1793 ++ SYS___SCANF_A = 0x702 // 1794 ++ SYS___SSCANF_A = 0x703 // 1795 ++ SYS___SWSCANF_A = 0x704 // 1796 ++ SYS___ATOF_A = 0x705 // 1797 ++ SYS___ATOI_A = 0x706 // 1798 ++ SYS___ATOL_A = 0x707 // 1799 ++ SYS___STRTOD_A = 0x708 // 1800 ++ SYS___STRTOL_A = 0x709 // 1801 ++ SYS___STRTOUL_A = 0x70A // 1802 ++ SYS_____AE_CORRESTBL_QUERY_A = 0x70B // 1803 ++ SYS___A64L_A = 0x70C // 1804 ++ SYS___ECVT_A = 0x70D // 1805 ++ SYS___FCVT_A = 0x70E // 1806 ++ SYS___GCVT_A = 0x70F // 1807 ++ SYS___L64A_A = 0x710 // 1808 ++ SYS___STRERROR_A = 0x711 // 1809 ++ SYS___PERROR_A = 0x712 // 1810 ++ SYS___FETCH_A = 0x713 // 1811 ++ SYS___GETENV_A = 0x714 // 1812 ++ SYS___MKSTEMP_A = 0x717 // 1815 ++ SYS___PTSNAME_A = 0x718 // 1816 ++ SYS___PUTENV_A = 0x719 // 1817 ++ SYS___REALPATH_A = 0x71A // 1818 ++ SYS___SETENV_A = 0x71B // 1819 ++ SYS___SYSTEM_A = 0x71C // 1820 ++ SYS___GETOPT_A = 0x71D // 1821 ++ SYS___CATOPEN_A = 0x71E // 1822 ++ SYS___ACCESS_A = 0x71F // 1823 ++ SYS___CHDIR_A = 0x720 // 1824 ++ SYS___CHOWN_A = 0x721 // 1825 ++ SYS___CHROOT_A = 0x722 // 1826 ++ SYS___GETCWD_A = 0x723 // 1827 ++ SYS___GETWD_A = 0x724 // 1828 ++ SYS___LCHOWN_A = 0x725 // 1829 ++ SYS___LINK_A = 0x726 // 1830 ++ SYS___PATHCONF_A = 0x727 // 1831 ++ SYS___IF_NAMEINDEX_A = 0x728 // 1832 ++ SYS___READLINK_A = 0x729 // 1833 ++ SYS___RMDIR_A = 0x72A // 1834 ++ SYS___STATVFS_A = 0x72B // 1835 ++ SYS___SYMLINK_A = 0x72C // 1836 ++ SYS___TRUNCATE_A = 0x72D // 1837 ++ SYS___UNLINK_A = 0x72E // 1838 ++ SYS___GAI_STRERROR_A = 0x72F // 1839 ++ SYS___EXTLINK_NP_A = 0x730 // 1840 ++ SYS___ISALNUM_A = 0x731 // 1841 ++ SYS___ISALPHA_A = 0x732 // 1842 ++ SYS___A2E_S = 0x733 // 1843 ++ SYS___ISCNTRL_A = 0x734 // 1844 ++ SYS___ISDIGIT_A = 0x735 // 1845 ++ SYS___ISGRAPH_A = 0x736 // 1846 ++ SYS___ISLOWER_A = 0x737 // 1847 ++ SYS___ISPRINT_A = 0x738 // 1848 ++ SYS___ISPUNCT_A = 0x739 // 1849 ++ SYS___ISSPACE_A = 0x73A // 1850 ++ SYS___ISUPPER_A = 0x73B // 1851 ++ SYS___ISXDIGIT_A = 0x73C // 1852 ++ SYS___TOLOWER_A = 0x73D // 1853 ++ SYS___TOUPPER_A = 0x73E // 1854 ++ SYS___ISWALNUM_A = 0x73F // 1855 ++ SYS___ISWALPHA_A = 0x740 // 1856 ++ SYS___A2E_L = 0x741 // 1857 ++ SYS___ISWCNTRL_A = 0x742 // 1858 ++ SYS___ISWDIGIT_A = 0x743 // 1859 ++ SYS___ISWGRAPH_A = 0x744 // 1860 ++ SYS___ISWLOWER_A = 0x745 // 1861 ++ SYS___ISWPRINT_A = 0x746 // 1862 ++ SYS___ISWPUNCT_A = 0x747 // 1863 ++ SYS___ISWSPACE_A = 0x748 // 1864 ++ SYS___ISWUPPER_A = 0x749 // 1865 ++ SYS___ISWXDIGIT_A = 0x74A // 1866 ++ SYS___CONFSTR_A = 0x74B // 1867 ++ SYS___FTOK_A = 0x74C // 1868 ++ SYS___MKTEMP_A = 0x74D // 1869 ++ SYS___FDOPEN_A = 0x74E // 1870 ++ SYS___FLDATA_A = 0x74F // 1871 ++ SYS___REMOVE_A = 0x750 // 1872 ++ SYS___RENAME_A = 0x751 // 1873 ++ SYS___TMPNAM_A = 0x752 // 1874 ++ SYS___FOPEN_A = 0x753 // 1875 ++ SYS___FREOPEN_A = 0x754 // 1876 ++ SYS___CUSERID_A = 0x755 // 1877 ++ SYS___POPEN_A = 0x756 // 1878 ++ SYS___TEMPNAM_A = 0x757 // 1879 ++ SYS___FTW_A = 0x758 // 1880 ++ SYS___GETGRENT_A = 0x759 // 1881 ++ SYS___GETGRGID_A = 0x75A // 1882 ++ SYS___GETGRNAM_A = 0x75B // 1883 ++ SYS___GETGROUPSBYNAME_A = 0x75C // 1884 ++ SYS___GETHOSTENT_A = 0x75D // 1885 ++ SYS___GETHOSTNAME_A = 0x75E // 1886 ++ SYS___GETLOGIN_A = 0x75F // 1887 ++ SYS___INET_NTOP_A = 0x760 // 1888 ++ SYS___GETPASS_A = 0x761 // 1889 ++ SYS___GETPWENT_A = 0x762 // 1890 ++ SYS___GETPWNAM_A = 0x763 // 1891 ++ SYS___GETPWUID_A = 0x764 // 1892 ++ SYS_____CHECK_RESOURCE_AUTH_NP_A = 0x765 // 1893 ++ SYS___CHECKSCHENV_A = 0x766 // 1894 ++ SYS___CONNECTSERVER_A = 0x767 // 1895 ++ SYS___CONNECTWORKMGR_A = 0x768 // 1896 ++ SYS_____CONSOLE_A = 0x769 // 1897 ++ SYS___CREATEWORKUNIT_A = 0x76A // 1898 ++ SYS___CTERMID_A = 0x76B // 1899 ++ SYS___FMTMSG_A = 0x76C // 1900 ++ SYS___INITGROUPS_A = 0x76D // 1901 ++ SYS_____LOGIN_A = 0x76E // 1902 ++ SYS___MSGRCV_A = 0x76F // 1903 ++ SYS___MSGSND_A = 0x770 // 1904 ++ SYS___MSGXRCV_A = 0x771 // 1905 ++ SYS___NFTW_A = 0x772 // 1906 ++ SYS_____PASSWD_A = 0x773 // 1907 ++ SYS___PTHREAD_SECURITY_NP_A = 0x774 // 1908 ++ SYS___QUERYMETRICS_A = 0x775 // 1909 ++ SYS___QUERYSCHENV = 0x776 // 1910 ++ SYS___READV_A = 0x777 // 1911 ++ SYS_____SERVER_CLASSIFY_A = 0x778 // 1912 ++ SYS_____SERVER_INIT_A = 0x779 // 1913 ++ SYS_____SERVER_PWU_A = 0x77A // 1914 ++ SYS___STRCASECMP_A = 0x77B // 1915 ++ SYS___STRNCASECMP_A = 0x77C // 1916 ++ SYS___TTYNAME_A = 0x77D // 1917 ++ SYS___UNAME_A = 0x77E // 1918 ++ SYS___UTIMES_A = 0x77F // 1919 ++ SYS___W_GETPSENT_A = 0x780 // 1920 ++ SYS___WRITEV_A = 0x781 // 1921 ++ SYS___W_STATFS_A = 0x782 // 1922 ++ SYS___W_STATVFS_A = 0x783 // 1923 ++ SYS___FPUTC_A = 0x784 // 1924 ++ SYS___PUTCHAR_A = 0x785 // 1925 ++ SYS___PUTS_A = 0x786 // 1926 ++ SYS___FGETS_A = 0x787 // 1927 ++ SYS___GETS_A = 0x788 // 1928 ++ SYS___FPUTS_A = 0x789 // 1929 ++ SYS___FREAD_A = 0x78A // 1930 ++ SYS___FWRITE_A = 0x78B // 1931 ++ SYS___OPEN_O_A = 0x78C // 1932 ++ SYS___ISASCII = 0x78D // 1933 ++ SYS___CREAT_O_A = 0x78E // 1934 ++ SYS___ENVNA = 0x78F // 1935 ++ SYS___PUTC_A = 0x790 // 1936 ++ SYS___AE_THREAD_SETMODE = 0x791 // 1937 ++ SYS___AE_THREAD_SWAPMODE = 0x792 // 1938 ++ SYS___GETNETBYADDR_A = 0x793 // 1939 ++ SYS___GETNETBYNAME_A = 0x794 // 1940 ++ SYS___GETNETENT_A = 0x795 // 1941 ++ SYS___GETPROTOBYNAME_A = 0x796 // 1942 ++ SYS___GETPROTOBYNUMBER_A = 0x797 // 1943 ++ SYS___GETPROTOENT_A = 0x798 // 1944 ++ SYS___GETSERVBYNAME_A = 0x799 // 1945 ++ SYS___GETSERVBYPORT_A = 0x79A // 1946 ++ SYS___GETSERVENT_A = 0x79B // 1947 ++ SYS___ASCTIME_A = 0x79C // 1948 ++ SYS___CTIME_A = 0x79D // 1949 ++ SYS___GETDATE_A = 0x79E // 1950 ++ SYS___TZSET_A = 0x79F // 1951 ++ SYS___UTIME_A = 0x7A0 // 1952 ++ SYS___ASCTIME_R_A = 0x7A1 // 1953 ++ SYS___CTIME_R_A = 0x7A2 // 1954 ++ SYS___STRTOLL_A = 0x7A3 // 1955 ++ SYS___STRTOULL_A = 0x7A4 // 1956 ++ SYS___FPUTWC_A = 0x7A5 // 1957 ++ SYS___PUTWC_A = 0x7A6 // 1958 ++ SYS___PUTWCHAR_A = 0x7A7 // 1959 ++ SYS___FPUTWS_A = 0x7A8 // 1960 ++ SYS___UNGETWC_A = 0x7A9 // 1961 ++ SYS___FGETWC_A = 0x7AA // 1962 ++ SYS___GETWC_A = 0x7AB // 1963 ++ SYS___GETWCHAR_A = 0x7AC // 1964 ++ SYS___FGETWS_A = 0x7AD // 1965 ++ SYS___GETTIMEOFDAY_A = 0x7AE // 1966 ++ SYS___GMTIME_A = 0x7AF // 1967 ++ SYS___GMTIME_R_A = 0x7B0 // 1968 ++ SYS___LOCALTIME_A = 0x7B1 // 1969 ++ SYS___LOCALTIME_R_A = 0x7B2 // 1970 ++ SYS___MKTIME_A = 0x7B3 // 1971 ++ SYS___TZZNA = 0x7B4 // 1972 ++ SYS_UNATEXIT = 0x7B5 // 1973 ++ SYS___CEE3DMP_A = 0x7B6 // 1974 ++ SYS___CDUMP_A = 0x7B7 // 1975 ++ SYS___CSNAP_A = 0x7B8 // 1976 ++ SYS___CTEST_A = 0x7B9 // 1977 ++ SYS___CTRACE_A = 0x7BA // 1978 ++ SYS___VSWPRNTF2_A = 0x7BB // 1979 ++ SYS___INET_PTON_A = 0x7BC // 1980 ++ SYS___SYSLOG_A = 0x7BD // 1981 ++ SYS___CRYPT_A = 0x7BE // 1982 ++ SYS_____OPENDIR2_A = 0x7BF // 1983 ++ SYS_____READDIR2_A = 0x7C0 // 1984 ++ SYS___OPENDIR_A = 0x7C2 // 1986 ++ SYS___READDIR_A = 0x7C3 // 1987 ++ SYS_PREAD = 0x7C7 // 1991 ++ SYS_PWRITE = 0x7C8 // 1992 ++ SYS_M_CREATE_LAYOUT = 0x7C9 // 1993 ++ SYS_M_DESTROY_LAYOUT = 0x7CA // 1994 ++ SYS_M_GETVALUES_LAYOUT = 0x7CB // 1995 ++ SYS_M_SETVALUES_LAYOUT = 0x7CC // 1996 ++ SYS_M_TRANSFORM_LAYOUT = 0x7CD // 1997 ++ SYS_M_WTRANSFORM_LAYOUT = 0x7CE // 1998 ++ SYS_FWPRINTF = 0x7D1 // 2001 ++ SYS_WPRINTF = 0x7D2 // 2002 ++ SYS_VFWPRINT = 0x7D3 // 2003 ++ SYS_VFWPRINTF = 0x7D3 // 2003 ++ SYS_VWPRINTF = 0x7D4 // 2004 ++ SYS_FWSCANF = 0x7D5 // 2005 ++ SYS_WSCANF = 0x7D6 // 2006 ++ SYS_WCTRANS = 0x7D7 // 2007 ++ SYS_TOWCTRAN = 0x7D8 // 2008 ++ SYS_TOWCTRANS = 0x7D8 // 2008 ++ SYS___WCSTOD_A = 0x7D9 // 2009 ++ SYS___WCSTOL_A = 0x7DA // 2010 ++ SYS___WCSTOUL_A = 0x7DB // 2011 ++ SYS___BASENAME_A = 0x7DC // 2012 ++ SYS___DIRNAME_A = 0x7DD // 2013 ++ SYS___GLOB_A = 0x7DE // 2014 ++ SYS_FWIDE = 0x7DF // 2015 ++ SYS___OSNAME = 0x7E0 // 2016 ++ SYS_____OSNAME_A = 0x7E1 // 2017 ++ SYS___BTOWC_A = 0x7E4 // 2020 ++ SYS___WCTOB_A = 0x7E5 // 2021 ++ SYS___DBM_OPEN_A = 0x7E6 // 2022 ++ SYS___VFPRINTF2_A = 0x7E7 // 2023 ++ SYS___VPRINTF2_A = 0x7E8 // 2024 ++ SYS___VSPRINTF2_A = 0x7E9 // 2025 ++ SYS___CEIL_H = 0x7EA // 2026 ++ SYS___FLOOR_H = 0x7EB // 2027 ++ SYS___MODF_H = 0x7EC // 2028 ++ SYS___FABS_H = 0x7ED // 2029 ++ SYS___J0_H = 0x7EE // 2030 ++ SYS___J1_H = 0x7EF // 2031 ++ SYS___JN_H = 0x7F0 // 2032 ++ SYS___Y0_H = 0x7F1 // 2033 ++ SYS___Y1_H = 0x7F2 // 2034 ++ SYS___YN_H = 0x7F3 // 2035 ++ SYS___CEILF_H = 0x7F4 // 2036 ++ SYS___CEILL_H = 0x7F5 // 2037 ++ SYS___FLOORF_H = 0x7F6 // 2038 ++ SYS___FLOORL_H = 0x7F7 // 2039 ++ SYS___MODFF_H = 0x7F8 // 2040 ++ SYS___MODFL_H = 0x7F9 // 2041 ++ SYS___FABSF_H = 0x7FA // 2042 ++ SYS___FABSL_H = 0x7FB // 2043 ++ SYS___MALLOC24 = 0x7FC // 2044 ++ SYS___MALLOC31 = 0x7FD // 2045 ++ SYS_ACL_INIT = 0x7FE // 2046 ++ SYS_ACL_FREE = 0x7FF // 2047 ++ SYS_ACL_FIRST_ENTRY = 0x800 // 2048 ++ SYS_ACL_GET_ENTRY = 0x801 // 2049 ++ SYS_ACL_VALID = 0x802 // 2050 ++ SYS_ACL_CREATE_ENTRY = 0x803 // 2051 ++ SYS_ACL_DELETE_ENTRY = 0x804 // 2052 ++ SYS_ACL_UPDATE_ENTRY = 0x805 // 2053 ++ SYS_ACL_DELETE_FD = 0x806 // 2054 ++ SYS_ACL_DELETE_FILE = 0x807 // 2055 ++ SYS_ACL_GET_FD = 0x808 // 2056 ++ SYS_ACL_GET_FILE = 0x809 // 2057 ++ SYS_ACL_SET_FD = 0x80A // 2058 ++ SYS_ACL_SET_FILE = 0x80B // 2059 ++ SYS_ACL_FROM_TEXT = 0x80C // 2060 ++ SYS_ACL_TO_TEXT = 0x80D // 2061 ++ SYS_ACL_SORT = 0x80E // 2062 ++ SYS___SHUTDOWN_REGISTRATION = 0x80F // 2063 ++ SYS___ERFL_B = 0x810 // 2064 ++ SYS___ERFCL_B = 0x811 // 2065 ++ SYS___LGAMMAL_B = 0x812 // 2066 ++ SYS___SETHOOKEVENTS = 0x813 // 2067 ++ SYS_IF_NAMETOINDEX = 0x814 // 2068 ++ SYS_IF_INDEXTONAME = 0x815 // 2069 ++ SYS_IF_NAMEINDEX = 0x816 // 2070 ++ SYS_IF_FREENAMEINDEX = 0x817 // 2071 ++ SYS_GETADDRINFO = 0x818 // 2072 ++ SYS_GETNAMEINFO = 0x819 // 2073 ++ SYS_FREEADDRINFO = 0x81A // 2074 ++ SYS_GAI_STRERROR = 0x81B // 2075 ++ SYS_REXEC_AF = 0x81C // 2076 ++ SYS___POE = 0x81D // 2077 ++ SYS___DYNALLOC_A = 0x81F // 2079 ++ SYS___DYNFREE_A = 0x820 // 2080 ++ SYS___RES_QUERY_A = 0x821 // 2081 ++ SYS___RES_SEARCH_A = 0x822 // 2082 ++ SYS___RES_QUERYDOMAIN_A = 0x823 // 2083 ++ SYS___RES_MKQUERY_A = 0x824 // 2084 ++ SYS___RES_SEND_A = 0x825 // 2085 ++ SYS___DN_EXPAND_A = 0x826 // 2086 ++ SYS___DN_SKIPNAME_A = 0x827 // 2087 ++ SYS___DN_COMP_A = 0x828 // 2088 ++ SYS___DN_FIND_A = 0x829 // 2089 ++ SYS___NLIST_A = 0x82A // 2090 ++ SYS_____TCGETCP_A = 0x82B // 2091 ++ SYS_____TCSETCP_A = 0x82C // 2092 ++ SYS_____W_PIOCTL_A = 0x82E // 2094 ++ SYS___INET_ADDR_A = 0x82F // 2095 ++ SYS___INET_NTOA_A = 0x830 // 2096 ++ SYS___INET_NETWORK_A = 0x831 // 2097 ++ SYS___ACCEPT_A = 0x832 // 2098 ++ SYS___ACCEPT_AND_RECV_A = 0x833 // 2099 ++ SYS___BIND_A = 0x834 // 2100 ++ SYS___CONNECT_A = 0x835 // 2101 ++ SYS___GETPEERNAME_A = 0x836 // 2102 ++ SYS___GETSOCKNAME_A = 0x837 // 2103 ++ SYS___RECVFROM_A = 0x838 // 2104 ++ SYS___SENDTO_A = 0x839 // 2105 ++ SYS___SENDMSG_A = 0x83A // 2106 ++ SYS___RECVMSG_A = 0x83B // 2107 ++ SYS_____LCHATTR_A = 0x83C // 2108 ++ SYS___CABEND = 0x83D // 2109 ++ SYS___LE_CIB_GET = 0x83E // 2110 ++ SYS___SET_LAA_FOR_JIT = 0x83F // 2111 ++ SYS___LCHATTR = 0x840 // 2112 ++ SYS___WRITEDOWN = 0x841 // 2113 ++ SYS_PTHREAD_MUTEX_INIT2 = 0x842 // 2114 ++ SYS___ACOSHF_B = 0x843 // 2115 ++ SYS___ACOSHL_B = 0x844 // 2116 ++ SYS___ASINHF_B = 0x845 // 2117 ++ SYS___ASINHL_B = 0x846 // 2118 ++ SYS___ATANHF_B = 0x847 // 2119 ++ SYS___ATANHL_B = 0x848 // 2120 ++ SYS___CBRTF_B = 0x849 // 2121 ++ SYS___CBRTL_B = 0x84A // 2122 ++ SYS___COPYSIGNF_B = 0x84B // 2123 ++ SYS___COPYSIGNL_B = 0x84C // 2124 ++ SYS___COTANF_B = 0x84D // 2125 ++ SYS___COTAN_B = 0x84E // 2126 ++ SYS___COTANL_B = 0x84F // 2127 ++ SYS___EXP2F_B = 0x850 // 2128 ++ SYS___EXP2L_B = 0x851 // 2129 ++ SYS___EXPM1F_B = 0x852 // 2130 ++ SYS___EXPM1L_B = 0x853 // 2131 ++ SYS___FDIMF_B = 0x854 // 2132 ++ SYS___FDIM_B = 0x855 // 2133 ++ SYS___FDIML_B = 0x856 // 2134 ++ SYS___HYPOTF_B = 0x857 // 2135 ++ SYS___HYPOTL_B = 0x858 // 2136 ++ SYS___LOG1PF_B = 0x859 // 2137 ++ SYS___LOG1PL_B = 0x85A // 2138 ++ SYS___LOG2F_B = 0x85B // 2139 ++ SYS___LOG2_B = 0x85C // 2140 ++ SYS___LOG2L_B = 0x85D // 2141 ++ SYS___REMAINDERF_B = 0x85E // 2142 ++ SYS___REMAINDERL_B = 0x85F // 2143 ++ SYS___REMQUOF_B = 0x860 // 2144 ++ SYS___REMQUO_B = 0x861 // 2145 ++ SYS___REMQUOL_B = 0x862 // 2146 ++ SYS___TGAMMAF_B = 0x863 // 2147 ++ SYS___TGAMMA_B = 0x864 // 2148 ++ SYS___TGAMMAL_B = 0x865 // 2149 ++ SYS___TRUNCF_B = 0x866 // 2150 ++ SYS___TRUNC_B = 0x867 // 2151 ++ SYS___TRUNCL_B = 0x868 // 2152 ++ SYS___LGAMMAF_B = 0x869 // 2153 ++ SYS___LROUNDF_B = 0x86A // 2154 ++ SYS___LROUND_B = 0x86B // 2155 ++ SYS___ERFF_B = 0x86C // 2156 ++ SYS___ERFCF_B = 0x86D // 2157 ++ SYS_ACOSHF = 0x86E // 2158 ++ SYS_ACOSHL = 0x86F // 2159 ++ SYS_ASINHF = 0x870 // 2160 ++ SYS_ASINHL = 0x871 // 2161 ++ SYS_ATANHF = 0x872 // 2162 ++ SYS_ATANHL = 0x873 // 2163 ++ SYS_CBRTF = 0x874 // 2164 ++ SYS_CBRTL = 0x875 // 2165 ++ SYS_COPYSIGNF = 0x876 // 2166 ++ SYS_CPYSIGNF = 0x876 // 2166 ++ SYS_COPYSIGNL = 0x877 // 2167 ++ SYS_CPYSIGNL = 0x877 // 2167 ++ SYS_COTANF = 0x878 // 2168 ++ SYS___COTANF = 0x878 // 2168 ++ SYS_COTAN = 0x879 // 2169 ++ SYS___COTAN = 0x879 // 2169 ++ SYS_COTANL = 0x87A // 2170 ++ SYS___COTANL = 0x87A // 2170 ++ SYS_EXP2F = 0x87B // 2171 ++ SYS_EXP2L = 0x87C // 2172 ++ SYS_EXPM1F = 0x87D // 2173 ++ SYS_EXPM1L = 0x87E // 2174 ++ SYS_FDIMF = 0x87F // 2175 ++ SYS_FDIM = 0x881 // 2177 ++ SYS_FDIML = 0x882 // 2178 ++ SYS_HYPOTF = 0x883 // 2179 ++ SYS_HYPOTL = 0x884 // 2180 ++ SYS_LOG1PF = 0x885 // 2181 ++ SYS_LOG1PL = 0x886 // 2182 ++ SYS_LOG2F = 0x887 // 2183 ++ SYS_LOG2 = 0x888 // 2184 ++ SYS_LOG2L = 0x889 // 2185 ++ SYS_REMAINDERF = 0x88A // 2186 ++ SYS_REMAINDF = 0x88A // 2186 ++ SYS_REMAINDERL = 0x88B // 2187 ++ SYS_REMAINDL = 0x88B // 2187 ++ SYS_REMQUOF = 0x88C // 2188 ++ SYS_REMQUO = 0x88D // 2189 ++ SYS_REMQUOL = 0x88E // 2190 ++ SYS_TGAMMAF = 0x88F // 2191 ++ SYS_TGAMMA = 0x890 // 2192 ++ SYS_TGAMMAL = 0x891 // 2193 ++ SYS_TRUNCF = 0x892 // 2194 ++ SYS_TRUNC = 0x893 // 2195 ++ SYS_TRUNCL = 0x894 // 2196 ++ SYS_LGAMMAF = 0x895 // 2197 ++ SYS_LGAMMAL = 0x896 // 2198 ++ SYS_LROUNDF = 0x897 // 2199 ++ SYS_LROUND = 0x898 // 2200 ++ SYS_ERFF = 0x899 // 2201 ++ SYS_ERFL = 0x89A // 2202 ++ SYS_ERFCF = 0x89B // 2203 ++ SYS_ERFCL = 0x89C // 2204 ++ SYS___EXP2_B = 0x89D // 2205 ++ SYS_EXP2 = 0x89E // 2206 ++ SYS___FAR_JUMP = 0x89F // 2207 ++ SYS___TCGETATTR_A = 0x8A1 // 2209 ++ SYS___TCSETATTR_A = 0x8A2 // 2210 ++ SYS___SUPERKILL = 0x8A4 // 2212 ++ SYS___LE_CONDITION_TOKEN_BUILD = 0x8A5 // 2213 ++ SYS___LE_MSG_ADD_INSERT = 0x8A6 // 2214 ++ SYS___LE_MSG_GET = 0x8A7 // 2215 ++ SYS___LE_MSG_GET_AND_WRITE = 0x8A8 // 2216 ++ SYS___LE_MSG_WRITE = 0x8A9 // 2217 ++ SYS___ITOA = 0x8AA // 2218 ++ SYS___UTOA = 0x8AB // 2219 ++ SYS___LTOA = 0x8AC // 2220 ++ SYS___ULTOA = 0x8AD // 2221 ++ SYS___LLTOA = 0x8AE // 2222 ++ SYS___ULLTOA = 0x8AF // 2223 ++ SYS___ITOA_A = 0x8B0 // 2224 ++ SYS___UTOA_A = 0x8B1 // 2225 ++ SYS___LTOA_A = 0x8B2 // 2226 ++ SYS___ULTOA_A = 0x8B3 // 2227 ++ SYS___LLTOA_A = 0x8B4 // 2228 ++ SYS___ULLTOA_A = 0x8B5 // 2229 ++ SYS_____GETENV_A = 0x8C3 // 2243 ++ SYS___REXEC_A = 0x8C4 // 2244 ++ SYS___REXEC_AF_A = 0x8C5 // 2245 ++ SYS___GETUTXENT_A = 0x8C6 // 2246 ++ SYS___GETUTXID_A = 0x8C7 // 2247 ++ SYS___GETUTXLINE_A = 0x8C8 // 2248 ++ SYS___PUTUTXLINE_A = 0x8C9 // 2249 ++ SYS_____UTMPXNAME_A = 0x8CA // 2250 ++ SYS___PUTC_UNLOCKED_A = 0x8CB // 2251 ++ SYS___PUTCHAR_UNLOCKED_A = 0x8CC // 2252 ++ SYS___SNPRINTF_A = 0x8CD // 2253 ++ SYS___VSNPRINTF_A = 0x8CE // 2254 ++ SYS___DLOPEN_A = 0x8D0 // 2256 ++ SYS___DLSYM_A = 0x8D1 // 2257 ++ SYS___DLERROR_A = 0x8D2 // 2258 ++ SYS_FLOCKFILE = 0x8D3 // 2259 ++ SYS_FTRYLOCKFILE = 0x8D4 // 2260 ++ SYS_FUNLOCKFILE = 0x8D5 // 2261 ++ SYS_GETC_UNLOCKED = 0x8D6 // 2262 ++ SYS_GETCHAR_UNLOCKED = 0x8D7 // 2263 ++ SYS_PUTC_UNLOCKED = 0x8D8 // 2264 ++ SYS_PUTCHAR_UNLOCKED = 0x8D9 // 2265 ++ SYS_SNPRINTF = 0x8DA // 2266 ++ SYS_VSNPRINTF = 0x8DB // 2267 ++ SYS_DLOPEN = 0x8DD // 2269 ++ SYS_DLSYM = 0x8DE // 2270 ++ SYS_DLCLOSE = 0x8DF // 2271 ++ SYS_DLERROR = 0x8E0 // 2272 ++ SYS___SET_EXCEPTION_HANDLER = 0x8E2 // 2274 ++ SYS___RESET_EXCEPTION_HANDLER = 0x8E3 // 2275 ++ SYS___VHM_EVENT = 0x8E4 // 2276 ++ SYS___ABS_H = 0x8E6 // 2278 ++ SYS___ABSF_H = 0x8E7 // 2279 ++ SYS___ABSL_H = 0x8E8 // 2280 ++ SYS___ACOS_H = 0x8E9 // 2281 ++ SYS___ACOSF_H = 0x8EA // 2282 ++ SYS___ACOSL_H = 0x8EB // 2283 ++ SYS___ACOSH_H = 0x8EC // 2284 ++ SYS___ASIN_H = 0x8ED // 2285 ++ SYS___ASINF_H = 0x8EE // 2286 ++ SYS___ASINL_H = 0x8EF // 2287 ++ SYS___ASINH_H = 0x8F0 // 2288 ++ SYS___ATAN_H = 0x8F1 // 2289 ++ SYS___ATANF_H = 0x8F2 // 2290 ++ SYS___ATANL_H = 0x8F3 // 2291 ++ SYS___ATANH_H = 0x8F4 // 2292 ++ SYS___ATANHF_H = 0x8F5 // 2293 ++ SYS___ATANHL_H = 0x8F6 // 2294 ++ SYS___ATAN2_H = 0x8F7 // 2295 ++ SYS___ATAN2F_H = 0x8F8 // 2296 ++ SYS___ATAN2L_H = 0x8F9 // 2297 ++ SYS___CBRT_H = 0x8FA // 2298 ++ SYS___COPYSIGNF_H = 0x8FB // 2299 ++ SYS___COPYSIGNL_H = 0x8FC // 2300 ++ SYS___COS_H = 0x8FD // 2301 ++ SYS___COSF_H = 0x8FE // 2302 ++ SYS___COSL_H = 0x8FF // 2303 ++ SYS___COSHF_H = 0x900 // 2304 ++ SYS___COSHL_H = 0x901 // 2305 ++ SYS___COTAN_H = 0x902 // 2306 ++ SYS___COTANF_H = 0x903 // 2307 ++ SYS___COTANL_H = 0x904 // 2308 ++ SYS___ERF_H = 0x905 // 2309 ++ SYS___ERFF_H = 0x906 // 2310 ++ SYS___ERFL_H = 0x907 // 2311 ++ SYS___ERFC_H = 0x908 // 2312 ++ SYS___ERFCF_H = 0x909 // 2313 ++ SYS___ERFCL_H = 0x90A // 2314 ++ SYS___EXP_H = 0x90B // 2315 ++ SYS___EXPF_H = 0x90C // 2316 ++ SYS___EXPL_H = 0x90D // 2317 ++ SYS___EXPM1_H = 0x90E // 2318 ++ SYS___FDIM_H = 0x90F // 2319 ++ SYS___FDIMF_H = 0x910 // 2320 ++ SYS___FDIML_H = 0x911 // 2321 ++ SYS___FMOD_H = 0x912 // 2322 ++ SYS___FMODF_H = 0x913 // 2323 ++ SYS___FMODL_H = 0x914 // 2324 ++ SYS___GAMMA_H = 0x915 // 2325 ++ SYS___HYPOT_H = 0x916 // 2326 ++ SYS___ILOGB_H = 0x917 // 2327 ++ SYS___LGAMMA_H = 0x918 // 2328 ++ SYS___LGAMMAF_H = 0x919 // 2329 ++ SYS___LOG_H = 0x91A // 2330 ++ SYS___LOGF_H = 0x91B // 2331 ++ SYS___LOGL_H = 0x91C // 2332 ++ SYS___LOGB_H = 0x91D // 2333 ++ SYS___LOG2_H = 0x91E // 2334 ++ SYS___LOG2F_H = 0x91F // 2335 ++ SYS___LOG2L_H = 0x920 // 2336 ++ SYS___LOG1P_H = 0x921 // 2337 ++ SYS___LOG10_H = 0x922 // 2338 ++ SYS___LOG10F_H = 0x923 // 2339 ++ SYS___LOG10L_H = 0x924 // 2340 ++ SYS___LROUND_H = 0x925 // 2341 ++ SYS___LROUNDF_H = 0x926 // 2342 ++ SYS___NEXTAFTER_H = 0x927 // 2343 ++ SYS___POW_H = 0x928 // 2344 ++ SYS___POWF_H = 0x929 // 2345 ++ SYS___POWL_H = 0x92A // 2346 ++ SYS___REMAINDER_H = 0x92B // 2347 ++ SYS___RINT_H = 0x92C // 2348 ++ SYS___SCALB_H = 0x92D // 2349 ++ SYS___SIN_H = 0x92E // 2350 ++ SYS___SINF_H = 0x92F // 2351 ++ SYS___SINL_H = 0x930 // 2352 ++ SYS___SINH_H = 0x931 // 2353 ++ SYS___SINHF_H = 0x932 // 2354 ++ SYS___SINHL_H = 0x933 // 2355 ++ SYS___SQRT_H = 0x934 // 2356 ++ SYS___SQRTF_H = 0x935 // 2357 ++ SYS___SQRTL_H = 0x936 // 2358 ++ SYS___TAN_H = 0x937 // 2359 ++ SYS___TANF_H = 0x938 // 2360 ++ SYS___TANL_H = 0x939 // 2361 ++ SYS___TANH_H = 0x93A // 2362 ++ SYS___TANHF_H = 0x93B // 2363 ++ SYS___TANHL_H = 0x93C // 2364 ++ SYS___TGAMMA_H = 0x93D // 2365 ++ SYS___TGAMMAF_H = 0x93E // 2366 ++ SYS___TRUNC_H = 0x93F // 2367 ++ SYS___TRUNCF_H = 0x940 // 2368 ++ SYS___TRUNCL_H = 0x941 // 2369 ++ SYS___COSH_H = 0x942 // 2370 ++ SYS___LE_DEBUG_SET_RESUME_MCH = 0x943 // 2371 ++ SYS_VFSCANF = 0x944 // 2372 ++ SYS_VSCANF = 0x946 // 2374 ++ SYS_VSSCANF = 0x948 // 2376 ++ SYS_VFWSCANF = 0x94A // 2378 ++ SYS_VWSCANF = 0x94C // 2380 ++ SYS_VSWSCANF = 0x94E // 2382 ++ SYS_IMAXABS = 0x950 // 2384 ++ SYS_IMAXDIV = 0x951 // 2385 ++ SYS_STRTOIMAX = 0x952 // 2386 ++ SYS_STRTOUMAX = 0x953 // 2387 ++ SYS_WCSTOIMAX = 0x954 // 2388 ++ SYS_WCSTOUMAX = 0x955 // 2389 ++ SYS_ATOLL = 0x956 // 2390 ++ SYS_STRTOF = 0x957 // 2391 ++ SYS_STRTOLD = 0x958 // 2392 ++ SYS_WCSTOF = 0x959 // 2393 ++ SYS_WCSTOLD = 0x95A // 2394 ++ SYS_INET6_RTH_SPACE = 0x95B // 2395 ++ SYS_INET6_RTH_INIT = 0x95C // 2396 ++ SYS_INET6_RTH_ADD = 0x95D // 2397 ++ SYS_INET6_RTH_REVERSE = 0x95E // 2398 ++ SYS_INET6_RTH_SEGMENTS = 0x95F // 2399 ++ SYS_INET6_RTH_GETADDR = 0x960 // 2400 ++ SYS_INET6_OPT_INIT = 0x961 // 2401 ++ SYS_INET6_OPT_APPEND = 0x962 // 2402 ++ SYS_INET6_OPT_FINISH = 0x963 // 2403 ++ SYS_INET6_OPT_SET_VAL = 0x964 // 2404 ++ SYS_INET6_OPT_NEXT = 0x965 // 2405 ++ SYS_INET6_OPT_FIND = 0x966 // 2406 ++ SYS_INET6_OPT_GET_VAL = 0x967 // 2407 ++ SYS___POW_I = 0x987 // 2439 ++ SYS___POW_I_B = 0x988 // 2440 ++ SYS___POW_I_H = 0x989 // 2441 ++ SYS___POW_II = 0x98A // 2442 ++ SYS___POW_II_B = 0x98B // 2443 ++ SYS___POW_II_H = 0x98C // 2444 ++ SYS_CABS = 0x98E // 2446 ++ SYS___CABS_B = 0x98F // 2447 ++ SYS___CABS_H = 0x990 // 2448 ++ SYS_CABSF = 0x991 // 2449 ++ SYS___CABSF_B = 0x992 // 2450 ++ SYS___CABSF_H = 0x993 // 2451 ++ SYS_CABSL = 0x994 // 2452 ++ SYS___CABSL_B = 0x995 // 2453 ++ SYS___CABSL_H = 0x996 // 2454 ++ SYS_CACOS = 0x997 // 2455 ++ SYS___CACOS_B = 0x998 // 2456 ++ SYS___CACOS_H = 0x999 // 2457 ++ SYS_CACOSF = 0x99A // 2458 ++ SYS___CACOSF_B = 0x99B // 2459 ++ SYS___CACOSF_H = 0x99C // 2460 ++ SYS_CACOSL = 0x99D // 2461 ++ SYS___CACOSL_B = 0x99E // 2462 ++ SYS___CACOSL_H = 0x99F // 2463 ++ SYS_CACOSH = 0x9A0 // 2464 ++ SYS___CACOSH_B = 0x9A1 // 2465 ++ SYS___CACOSH_H = 0x9A2 // 2466 ++ SYS_CACOSHF = 0x9A3 // 2467 ++ SYS___CACOSHF_B = 0x9A4 // 2468 ++ SYS___CACOSHF_H = 0x9A5 // 2469 ++ SYS_CACOSHL = 0x9A6 // 2470 ++ SYS___CACOSHL_B = 0x9A7 // 2471 ++ SYS___CACOSHL_H = 0x9A8 // 2472 ++ SYS_CARG = 0x9A9 // 2473 ++ SYS___CARG_B = 0x9AA // 2474 ++ SYS___CARG_H = 0x9AB // 2475 ++ SYS_CARGF = 0x9AC // 2476 ++ SYS___CARGF_B = 0x9AD // 2477 ++ SYS___CARGF_H = 0x9AE // 2478 ++ SYS_CARGL = 0x9AF // 2479 ++ SYS___CARGL_B = 0x9B0 // 2480 ++ SYS___CARGL_H = 0x9B1 // 2481 ++ SYS_CASIN = 0x9B2 // 2482 ++ SYS___CASIN_B = 0x9B3 // 2483 ++ SYS___CASIN_H = 0x9B4 // 2484 ++ SYS_CASINF = 0x9B5 // 2485 ++ SYS___CASINF_B = 0x9B6 // 2486 ++ SYS___CASINF_H = 0x9B7 // 2487 ++ SYS_CASINL = 0x9B8 // 2488 ++ SYS___CASINL_B = 0x9B9 // 2489 ++ SYS___CASINL_H = 0x9BA // 2490 ++ SYS_CASINH = 0x9BB // 2491 ++ SYS___CASINH_B = 0x9BC // 2492 ++ SYS___CASINH_H = 0x9BD // 2493 ++ SYS_CASINHF = 0x9BE // 2494 ++ SYS___CASINHF_B = 0x9BF // 2495 ++ SYS___CASINHF_H = 0x9C0 // 2496 ++ SYS_CASINHL = 0x9C1 // 2497 ++ SYS___CASINHL_B = 0x9C2 // 2498 ++ SYS___CASINHL_H = 0x9C3 // 2499 ++ SYS_CATAN = 0x9C4 // 2500 ++ SYS___CATAN_B = 0x9C5 // 2501 ++ SYS___CATAN_H = 0x9C6 // 2502 ++ SYS_CATANF = 0x9C7 // 2503 ++ SYS___CATANF_B = 0x9C8 // 2504 ++ SYS___CATANF_H = 0x9C9 // 2505 ++ SYS_CATANL = 0x9CA // 2506 ++ SYS___CATANL_B = 0x9CB // 2507 ++ SYS___CATANL_H = 0x9CC // 2508 ++ SYS_CATANH = 0x9CD // 2509 ++ SYS___CATANH_B = 0x9CE // 2510 ++ SYS___CATANH_H = 0x9CF // 2511 ++ SYS_CATANHF = 0x9D0 // 2512 ++ SYS___CATANHF_B = 0x9D1 // 2513 ++ SYS___CATANHF_H = 0x9D2 // 2514 ++ SYS_CATANHL = 0x9D3 // 2515 ++ SYS___CATANHL_B = 0x9D4 // 2516 ++ SYS___CATANHL_H = 0x9D5 // 2517 ++ SYS_CCOS = 0x9D6 // 2518 ++ SYS___CCOS_B = 0x9D7 // 2519 ++ SYS___CCOS_H = 0x9D8 // 2520 ++ SYS_CCOSF = 0x9D9 // 2521 ++ SYS___CCOSF_B = 0x9DA // 2522 ++ SYS___CCOSF_H = 0x9DB // 2523 ++ SYS_CCOSL = 0x9DC // 2524 ++ SYS___CCOSL_B = 0x9DD // 2525 ++ SYS___CCOSL_H = 0x9DE // 2526 ++ SYS_CCOSH = 0x9DF // 2527 ++ SYS___CCOSH_B = 0x9E0 // 2528 ++ SYS___CCOSH_H = 0x9E1 // 2529 ++ SYS_CCOSHF = 0x9E2 // 2530 ++ SYS___CCOSHF_B = 0x9E3 // 2531 ++ SYS___CCOSHF_H = 0x9E4 // 2532 ++ SYS_CCOSHL = 0x9E5 // 2533 ++ SYS___CCOSHL_B = 0x9E6 // 2534 ++ SYS___CCOSHL_H = 0x9E7 // 2535 ++ SYS_CEXP = 0x9E8 // 2536 ++ SYS___CEXP_B = 0x9E9 // 2537 ++ SYS___CEXP_H = 0x9EA // 2538 ++ SYS_CEXPF = 0x9EB // 2539 ++ SYS___CEXPF_B = 0x9EC // 2540 ++ SYS___CEXPF_H = 0x9ED // 2541 ++ SYS_CEXPL = 0x9EE // 2542 ++ SYS___CEXPL_B = 0x9EF // 2543 ++ SYS___CEXPL_H = 0x9F0 // 2544 ++ SYS_CIMAG = 0x9F1 // 2545 ++ SYS___CIMAG_B = 0x9F2 // 2546 ++ SYS___CIMAG_H = 0x9F3 // 2547 ++ SYS_CIMAGF = 0x9F4 // 2548 ++ SYS___CIMAGF_B = 0x9F5 // 2549 ++ SYS___CIMAGF_H = 0x9F6 // 2550 ++ SYS_CIMAGL = 0x9F7 // 2551 ++ SYS___CIMAGL_B = 0x9F8 // 2552 ++ SYS___CIMAGL_H = 0x9F9 // 2553 ++ SYS___CLOG = 0x9FA // 2554 ++ SYS___CLOG_B = 0x9FB // 2555 ++ SYS___CLOG_H = 0x9FC // 2556 ++ SYS_CLOGF = 0x9FD // 2557 ++ SYS___CLOGF_B = 0x9FE // 2558 ++ SYS___CLOGF_H = 0x9FF // 2559 ++ SYS_CLOGL = 0xA00 // 2560 ++ SYS___CLOGL_B = 0xA01 // 2561 ++ SYS___CLOGL_H = 0xA02 // 2562 ++ SYS_CONJ = 0xA03 // 2563 ++ SYS___CONJ_B = 0xA04 // 2564 ++ SYS___CONJ_H = 0xA05 // 2565 ++ SYS_CONJF = 0xA06 // 2566 ++ SYS___CONJF_B = 0xA07 // 2567 ++ SYS___CONJF_H = 0xA08 // 2568 ++ SYS_CONJL = 0xA09 // 2569 ++ SYS___CONJL_B = 0xA0A // 2570 ++ SYS___CONJL_H = 0xA0B // 2571 ++ SYS_CPOW = 0xA0C // 2572 ++ SYS___CPOW_B = 0xA0D // 2573 ++ SYS___CPOW_H = 0xA0E // 2574 ++ SYS_CPOWF = 0xA0F // 2575 ++ SYS___CPOWF_B = 0xA10 // 2576 ++ SYS___CPOWF_H = 0xA11 // 2577 ++ SYS_CPOWL = 0xA12 // 2578 ++ SYS___CPOWL_B = 0xA13 // 2579 ++ SYS___CPOWL_H = 0xA14 // 2580 ++ SYS_CPROJ = 0xA15 // 2581 ++ SYS___CPROJ_B = 0xA16 // 2582 ++ SYS___CPROJ_H = 0xA17 // 2583 ++ SYS_CPROJF = 0xA18 // 2584 ++ SYS___CPROJF_B = 0xA19 // 2585 ++ SYS___CPROJF_H = 0xA1A // 2586 ++ SYS_CPROJL = 0xA1B // 2587 ++ SYS___CPROJL_B = 0xA1C // 2588 ++ SYS___CPROJL_H = 0xA1D // 2589 ++ SYS_CREAL = 0xA1E // 2590 ++ SYS___CREAL_B = 0xA1F // 2591 ++ SYS___CREAL_H = 0xA20 // 2592 ++ SYS_CREALF = 0xA21 // 2593 ++ SYS___CREALF_B = 0xA22 // 2594 ++ SYS___CREALF_H = 0xA23 // 2595 ++ SYS_CREALL = 0xA24 // 2596 ++ SYS___CREALL_B = 0xA25 // 2597 ++ SYS___CREALL_H = 0xA26 // 2598 ++ SYS_CSIN = 0xA27 // 2599 ++ SYS___CSIN_B = 0xA28 // 2600 ++ SYS___CSIN_H = 0xA29 // 2601 ++ SYS_CSINF = 0xA2A // 2602 ++ SYS___CSINF_B = 0xA2B // 2603 ++ SYS___CSINF_H = 0xA2C // 2604 ++ SYS_CSINL = 0xA2D // 2605 ++ SYS___CSINL_B = 0xA2E // 2606 ++ SYS___CSINL_H = 0xA2F // 2607 ++ SYS_CSINH = 0xA30 // 2608 ++ SYS___CSINH_B = 0xA31 // 2609 ++ SYS___CSINH_H = 0xA32 // 2610 ++ SYS_CSINHF = 0xA33 // 2611 ++ SYS___CSINHF_B = 0xA34 // 2612 ++ SYS___CSINHF_H = 0xA35 // 2613 ++ SYS_CSINHL = 0xA36 // 2614 ++ SYS___CSINHL_B = 0xA37 // 2615 ++ SYS___CSINHL_H = 0xA38 // 2616 ++ SYS_CSQRT = 0xA39 // 2617 ++ SYS___CSQRT_B = 0xA3A // 2618 ++ SYS___CSQRT_H = 0xA3B // 2619 ++ SYS_CSQRTF = 0xA3C // 2620 ++ SYS___CSQRTF_B = 0xA3D // 2621 ++ SYS___CSQRTF_H = 0xA3E // 2622 ++ SYS_CSQRTL = 0xA3F // 2623 ++ SYS___CSQRTL_B = 0xA40 // 2624 ++ SYS___CSQRTL_H = 0xA41 // 2625 ++ SYS_CTAN = 0xA42 // 2626 ++ SYS___CTAN_B = 0xA43 // 2627 ++ SYS___CTAN_H = 0xA44 // 2628 ++ SYS_CTANF = 0xA45 // 2629 ++ SYS___CTANF_B = 0xA46 // 2630 ++ SYS___CTANF_H = 0xA47 // 2631 ++ SYS_CTANL = 0xA48 // 2632 ++ SYS___CTANL_B = 0xA49 // 2633 ++ SYS___CTANL_H = 0xA4A // 2634 ++ SYS_CTANH = 0xA4B // 2635 ++ SYS___CTANH_B = 0xA4C // 2636 ++ SYS___CTANH_H = 0xA4D // 2637 ++ SYS_CTANHF = 0xA4E // 2638 ++ SYS___CTANHF_B = 0xA4F // 2639 ++ SYS___CTANHF_H = 0xA50 // 2640 ++ SYS_CTANHL = 0xA51 // 2641 ++ SYS___CTANHL_B = 0xA52 // 2642 ++ SYS___CTANHL_H = 0xA53 // 2643 ++ SYS___ACOSHF_H = 0xA54 // 2644 ++ SYS___ACOSHL_H = 0xA55 // 2645 ++ SYS___ASINHF_H = 0xA56 // 2646 ++ SYS___ASINHL_H = 0xA57 // 2647 ++ SYS___CBRTF_H = 0xA58 // 2648 ++ SYS___CBRTL_H = 0xA59 // 2649 ++ SYS___COPYSIGN_B = 0xA5A // 2650 ++ SYS___EXPM1F_H = 0xA5B // 2651 ++ SYS___EXPM1L_H = 0xA5C // 2652 ++ SYS___EXP2_H = 0xA5D // 2653 ++ SYS___EXP2F_H = 0xA5E // 2654 ++ SYS___EXP2L_H = 0xA5F // 2655 ++ SYS___LOG1PF_H = 0xA60 // 2656 ++ SYS___LOG1PL_H = 0xA61 // 2657 ++ SYS___LGAMMAL_H = 0xA62 // 2658 ++ SYS_FMA = 0xA63 // 2659 ++ SYS___FMA_B = 0xA64 // 2660 ++ SYS___FMA_H = 0xA65 // 2661 ++ SYS_FMAF = 0xA66 // 2662 ++ SYS___FMAF_B = 0xA67 // 2663 ++ SYS___FMAF_H = 0xA68 // 2664 ++ SYS_FMAL = 0xA69 // 2665 ++ SYS___FMAL_B = 0xA6A // 2666 ++ SYS___FMAL_H = 0xA6B // 2667 ++ SYS_FMAX = 0xA6C // 2668 ++ SYS___FMAX_B = 0xA6D // 2669 ++ SYS___FMAX_H = 0xA6E // 2670 ++ SYS_FMAXF = 0xA6F // 2671 ++ SYS___FMAXF_B = 0xA70 // 2672 ++ SYS___FMAXF_H = 0xA71 // 2673 ++ SYS_FMAXL = 0xA72 // 2674 ++ SYS___FMAXL_B = 0xA73 // 2675 ++ SYS___FMAXL_H = 0xA74 // 2676 ++ SYS_FMIN = 0xA75 // 2677 ++ SYS___FMIN_B = 0xA76 // 2678 ++ SYS___FMIN_H = 0xA77 // 2679 ++ SYS_FMINF = 0xA78 // 2680 ++ SYS___FMINF_B = 0xA79 // 2681 ++ SYS___FMINF_H = 0xA7A // 2682 ++ SYS_FMINL = 0xA7B // 2683 ++ SYS___FMINL_B = 0xA7C // 2684 ++ SYS___FMINL_H = 0xA7D // 2685 ++ SYS_ILOGBF = 0xA7E // 2686 ++ SYS___ILOGBF_B = 0xA7F // 2687 ++ SYS___ILOGBF_H = 0xA80 // 2688 ++ SYS_ILOGBL = 0xA81 // 2689 ++ SYS___ILOGBL_B = 0xA82 // 2690 ++ SYS___ILOGBL_H = 0xA83 // 2691 ++ SYS_LLRINT = 0xA84 // 2692 ++ SYS___LLRINT_B = 0xA85 // 2693 ++ SYS___LLRINT_H = 0xA86 // 2694 ++ SYS_LLRINTF = 0xA87 // 2695 ++ SYS___LLRINTF_B = 0xA88 // 2696 ++ SYS___LLRINTF_H = 0xA89 // 2697 ++ SYS_LLRINTL = 0xA8A // 2698 ++ SYS___LLRINTL_B = 0xA8B // 2699 ++ SYS___LLRINTL_H = 0xA8C // 2700 ++ SYS_LLROUND = 0xA8D // 2701 ++ SYS___LLROUND_B = 0xA8E // 2702 ++ SYS___LLROUND_H = 0xA8F // 2703 ++ SYS_LLROUNDF = 0xA90 // 2704 ++ SYS___LLROUNDF_B = 0xA91 // 2705 ++ SYS___LLROUNDF_H = 0xA92 // 2706 ++ SYS_LLROUNDL = 0xA93 // 2707 ++ SYS___LLROUNDL_B = 0xA94 // 2708 ++ SYS___LLROUNDL_H = 0xA95 // 2709 ++ SYS_LOGBF = 0xA96 // 2710 ++ SYS___LOGBF_B = 0xA97 // 2711 ++ SYS___LOGBF_H = 0xA98 // 2712 ++ SYS_LOGBL = 0xA99 // 2713 ++ SYS___LOGBL_B = 0xA9A // 2714 ++ SYS___LOGBL_H = 0xA9B // 2715 ++ SYS_LRINT = 0xA9C // 2716 ++ SYS___LRINT_B = 0xA9D // 2717 ++ SYS___LRINT_H = 0xA9E // 2718 ++ SYS_LRINTF = 0xA9F // 2719 ++ SYS___LRINTF_B = 0xAA0 // 2720 ++ SYS___LRINTF_H = 0xAA1 // 2721 ++ SYS_LRINTL = 0xAA2 // 2722 ++ SYS___LRINTL_B = 0xAA3 // 2723 ++ SYS___LRINTL_H = 0xAA4 // 2724 ++ SYS_LROUNDL = 0xAA5 // 2725 ++ SYS___LROUNDL_B = 0xAA6 // 2726 ++ SYS___LROUNDL_H = 0xAA7 // 2727 ++ SYS_NAN = 0xAA8 // 2728 ++ SYS___NAN_B = 0xAA9 // 2729 ++ SYS_NANF = 0xAAA // 2730 ++ SYS___NANF_B = 0xAAB // 2731 ++ SYS_NANL = 0xAAC // 2732 ++ SYS___NANL_B = 0xAAD // 2733 ++ SYS_NEARBYINT = 0xAAE // 2734 ++ SYS___NEARBYINT_B = 0xAAF // 2735 ++ SYS___NEARBYINT_H = 0xAB0 // 2736 ++ SYS_NEARBYINTF = 0xAB1 // 2737 ++ SYS___NEARBYINTF_B = 0xAB2 // 2738 ++ SYS___NEARBYINTF_H = 0xAB3 // 2739 ++ SYS_NEARBYINTL = 0xAB4 // 2740 ++ SYS___NEARBYINTL_B = 0xAB5 // 2741 ++ SYS___NEARBYINTL_H = 0xAB6 // 2742 ++ SYS_NEXTAFTERF = 0xAB7 // 2743 ++ SYS___NEXTAFTERF_B = 0xAB8 // 2744 ++ SYS___NEXTAFTERF_H = 0xAB9 // 2745 ++ SYS_NEXTAFTERL = 0xABA // 2746 ++ SYS___NEXTAFTERL_B = 0xABB // 2747 ++ SYS___NEXTAFTERL_H = 0xABC // 2748 ++ SYS_NEXTTOWARD = 0xABD // 2749 ++ SYS___NEXTTOWARD_B = 0xABE // 2750 ++ SYS___NEXTTOWARD_H = 0xABF // 2751 ++ SYS_NEXTTOWARDF = 0xAC0 // 2752 ++ SYS___NEXTTOWARDF_B = 0xAC1 // 2753 ++ SYS___NEXTTOWARDF_H = 0xAC2 // 2754 ++ SYS_NEXTTOWARDL = 0xAC3 // 2755 ++ SYS___NEXTTOWARDL_B = 0xAC4 // 2756 ++ SYS___NEXTTOWARDL_H = 0xAC5 // 2757 ++ SYS___REMAINDERF_H = 0xAC6 // 2758 ++ SYS___REMAINDERL_H = 0xAC7 // 2759 ++ SYS___REMQUO_H = 0xAC8 // 2760 ++ SYS___REMQUOF_H = 0xAC9 // 2761 ++ SYS___REMQUOL_H = 0xACA // 2762 ++ SYS_RINTF = 0xACB // 2763 ++ SYS___RINTF_B = 0xACC // 2764 ++ SYS_RINTL = 0xACD // 2765 ++ SYS___RINTL_B = 0xACE // 2766 ++ SYS_ROUND = 0xACF // 2767 ++ SYS___ROUND_B = 0xAD0 // 2768 ++ SYS___ROUND_H = 0xAD1 // 2769 ++ SYS_ROUNDF = 0xAD2 // 2770 ++ SYS___ROUNDF_B = 0xAD3 // 2771 ++ SYS___ROUNDF_H = 0xAD4 // 2772 ++ SYS_ROUNDL = 0xAD5 // 2773 ++ SYS___ROUNDL_B = 0xAD6 // 2774 ++ SYS___ROUNDL_H = 0xAD7 // 2775 ++ SYS_SCALBLN = 0xAD8 // 2776 ++ SYS___SCALBLN_B = 0xAD9 // 2777 ++ SYS___SCALBLN_H = 0xADA // 2778 ++ SYS_SCALBLNF = 0xADB // 2779 ++ SYS___SCALBLNF_B = 0xADC // 2780 ++ SYS___SCALBLNF_H = 0xADD // 2781 ++ SYS_SCALBLNL = 0xADE // 2782 ++ SYS___SCALBLNL_B = 0xADF // 2783 ++ SYS___SCALBLNL_H = 0xAE0 // 2784 ++ SYS___SCALBN_B = 0xAE1 // 2785 ++ SYS___SCALBN_H = 0xAE2 // 2786 ++ SYS_SCALBNF = 0xAE3 // 2787 ++ SYS___SCALBNF_B = 0xAE4 // 2788 ++ SYS___SCALBNF_H = 0xAE5 // 2789 ++ SYS_SCALBNL = 0xAE6 // 2790 ++ SYS___SCALBNL_B = 0xAE7 // 2791 ++ SYS___SCALBNL_H = 0xAE8 // 2792 ++ SYS___TGAMMAL_H = 0xAE9 // 2793 ++ SYS_FECLEAREXCEPT = 0xAEA // 2794 ++ SYS_FEGETENV = 0xAEB // 2795 ++ SYS_FEGETEXCEPTFLAG = 0xAEC // 2796 ++ SYS_FEGETROUND = 0xAED // 2797 ++ SYS_FEHOLDEXCEPT = 0xAEE // 2798 ++ SYS_FERAISEEXCEPT = 0xAEF // 2799 ++ SYS_FESETENV = 0xAF0 // 2800 ++ SYS_FESETEXCEPTFLAG = 0xAF1 // 2801 ++ SYS_FESETROUND = 0xAF2 // 2802 ++ SYS_FETESTEXCEPT = 0xAF3 // 2803 ++ SYS_FEUPDATEENV = 0xAF4 // 2804 ++ SYS___COPYSIGN_H = 0xAF5 // 2805 ++ SYS___HYPOTF_H = 0xAF6 // 2806 ++ SYS___HYPOTL_H = 0xAF7 // 2807 ++ SYS___CLASS = 0xAFA // 2810 ++ SYS___CLASS_B = 0xAFB // 2811 ++ SYS___CLASS_H = 0xAFC // 2812 ++ SYS___ISBLANK_A = 0xB2E // 2862 ++ SYS___ISWBLANK_A = 0xB2F // 2863 ++ SYS___LROUND_FIXUP = 0xB30 // 2864 ++ SYS___LROUNDF_FIXUP = 0xB31 // 2865 ++ SYS_SCHED_YIELD = 0xB32 // 2866 ++ SYS_STRERROR_R = 0xB33 // 2867 ++ SYS_UNSETENV = 0xB34 // 2868 ++ SYS___LGAMMA_H_C99 = 0xB38 // 2872 ++ SYS___LGAMMA_B_C99 = 0xB39 // 2873 ++ SYS___LGAMMA_R_C99 = 0xB3A // 2874 ++ SYS___FTELL2 = 0xB3B // 2875 ++ SYS___FSEEK2 = 0xB3C // 2876 ++ SYS___STATIC_REINIT = 0xB3D // 2877 ++ SYS_PTHREAD_ATTR_GETSTACK = 0xB3E // 2878 ++ SYS_PTHREAD_ATTR_SETSTACK = 0xB3F // 2879 ++ SYS___TGAMMA_H_C99 = 0xB78 // 2936 ++ SYS___TGAMMAF_H_C99 = 0xB79 // 2937 ++ SYS___LE_TRACEBACK = 0xB7A // 2938 ++ SYS___MUST_STAY_CLEAN = 0xB7C // 2940 ++ SYS___O_ENV = 0xB7D // 2941 ++ SYS_ACOSD32 = 0xB7E // 2942 ++ SYS_ACOSD64 = 0xB7F // 2943 ++ SYS_ACOSD128 = 0xB80 // 2944 ++ SYS_ACOSHD32 = 0xB81 // 2945 ++ SYS_ACOSHD64 = 0xB82 // 2946 ++ SYS_ACOSHD128 = 0xB83 // 2947 ++ SYS_ASIND32 = 0xB84 // 2948 ++ SYS_ASIND64 = 0xB85 // 2949 ++ SYS_ASIND128 = 0xB86 // 2950 ++ SYS_ASINHD32 = 0xB87 // 2951 ++ SYS_ASINHD64 = 0xB88 // 2952 ++ SYS_ASINHD128 = 0xB89 // 2953 ++ SYS_ATAND32 = 0xB8A // 2954 ++ SYS_ATAND64 = 0xB8B // 2955 ++ SYS_ATAND128 = 0xB8C // 2956 ++ SYS_ATAN2D32 = 0xB8D // 2957 ++ SYS_ATAN2D64 = 0xB8E // 2958 ++ SYS_ATAN2D128 = 0xB8F // 2959 ++ SYS_ATANHD32 = 0xB90 // 2960 ++ SYS_ATANHD64 = 0xB91 // 2961 ++ SYS_ATANHD128 = 0xB92 // 2962 ++ SYS_CBRTD32 = 0xB93 // 2963 ++ SYS_CBRTD64 = 0xB94 // 2964 ++ SYS_CBRTD128 = 0xB95 // 2965 ++ SYS_CEILD32 = 0xB96 // 2966 ++ SYS_CEILD64 = 0xB97 // 2967 ++ SYS_CEILD128 = 0xB98 // 2968 ++ SYS___CLASS2 = 0xB99 // 2969 ++ SYS___CLASS2_B = 0xB9A // 2970 ++ SYS___CLASS2_H = 0xB9B // 2971 ++ SYS_COPYSIGND32 = 0xB9C // 2972 ++ SYS_COPYSIGND64 = 0xB9D // 2973 ++ SYS_COPYSIGND128 = 0xB9E // 2974 ++ SYS_COSD32 = 0xB9F // 2975 ++ SYS_COSD64 = 0xBA0 // 2976 ++ SYS_COSD128 = 0xBA1 // 2977 ++ SYS_COSHD32 = 0xBA2 // 2978 ++ SYS_COSHD64 = 0xBA3 // 2979 ++ SYS_COSHD128 = 0xBA4 // 2980 ++ SYS_ERFD32 = 0xBA5 // 2981 ++ SYS_ERFD64 = 0xBA6 // 2982 ++ SYS_ERFD128 = 0xBA7 // 2983 ++ SYS_ERFCD32 = 0xBA8 // 2984 ++ SYS_ERFCD64 = 0xBA9 // 2985 ++ SYS_ERFCD128 = 0xBAA // 2986 ++ SYS_EXPD32 = 0xBAB // 2987 ++ SYS_EXPD64 = 0xBAC // 2988 ++ SYS_EXPD128 = 0xBAD // 2989 ++ SYS_EXP2D32 = 0xBAE // 2990 ++ SYS_EXP2D64 = 0xBAF // 2991 ++ SYS_EXP2D128 = 0xBB0 // 2992 ++ SYS_EXPM1D32 = 0xBB1 // 2993 ++ SYS_EXPM1D64 = 0xBB2 // 2994 ++ SYS_EXPM1D128 = 0xBB3 // 2995 ++ SYS_FABSD32 = 0xBB4 // 2996 ++ SYS_FABSD64 = 0xBB5 // 2997 ++ SYS_FABSD128 = 0xBB6 // 2998 ++ SYS_FDIMD32 = 0xBB7 // 2999 ++ SYS_FDIMD64 = 0xBB8 // 3000 ++ SYS_FDIMD128 = 0xBB9 // 3001 ++ SYS_FE_DEC_GETROUND = 0xBBA // 3002 ++ SYS_FE_DEC_SETROUND = 0xBBB // 3003 ++ SYS_FLOORD32 = 0xBBC // 3004 ++ SYS_FLOORD64 = 0xBBD // 3005 ++ SYS_FLOORD128 = 0xBBE // 3006 ++ SYS_FMAD32 = 0xBBF // 3007 ++ SYS_FMAD64 = 0xBC0 // 3008 ++ SYS_FMAD128 = 0xBC1 // 3009 ++ SYS_FMAXD32 = 0xBC2 // 3010 ++ SYS_FMAXD64 = 0xBC3 // 3011 ++ SYS_FMAXD128 = 0xBC4 // 3012 ++ SYS_FMIND32 = 0xBC5 // 3013 ++ SYS_FMIND64 = 0xBC6 // 3014 ++ SYS_FMIND128 = 0xBC7 // 3015 ++ SYS_FMODD32 = 0xBC8 // 3016 ++ SYS_FMODD64 = 0xBC9 // 3017 ++ SYS_FMODD128 = 0xBCA // 3018 ++ SYS___FP_CAST_D = 0xBCB // 3019 ++ SYS_FREXPD32 = 0xBCC // 3020 ++ SYS_FREXPD64 = 0xBCD // 3021 ++ SYS_FREXPD128 = 0xBCE // 3022 ++ SYS_HYPOTD32 = 0xBCF // 3023 ++ SYS_HYPOTD64 = 0xBD0 // 3024 ++ SYS_HYPOTD128 = 0xBD1 // 3025 ++ SYS_ILOGBD32 = 0xBD2 // 3026 ++ SYS_ILOGBD64 = 0xBD3 // 3027 ++ SYS_ILOGBD128 = 0xBD4 // 3028 ++ SYS_LDEXPD32 = 0xBD5 // 3029 ++ SYS_LDEXPD64 = 0xBD6 // 3030 ++ SYS_LDEXPD128 = 0xBD7 // 3031 ++ SYS_LGAMMAD32 = 0xBD8 // 3032 ++ SYS_LGAMMAD64 = 0xBD9 // 3033 ++ SYS_LGAMMAD128 = 0xBDA // 3034 ++ SYS_LLRINTD32 = 0xBDB // 3035 ++ SYS_LLRINTD64 = 0xBDC // 3036 ++ SYS_LLRINTD128 = 0xBDD // 3037 ++ SYS_LLROUNDD32 = 0xBDE // 3038 ++ SYS_LLROUNDD64 = 0xBDF // 3039 ++ SYS_LLROUNDD128 = 0xBE0 // 3040 ++ SYS_LOGD32 = 0xBE1 // 3041 ++ SYS_LOGD64 = 0xBE2 // 3042 ++ SYS_LOGD128 = 0xBE3 // 3043 ++ SYS_LOG10D32 = 0xBE4 // 3044 ++ SYS_LOG10D64 = 0xBE5 // 3045 ++ SYS_LOG10D128 = 0xBE6 // 3046 ++ SYS_LOG1PD32 = 0xBE7 // 3047 ++ SYS_LOG1PD64 = 0xBE8 // 3048 ++ SYS_LOG1PD128 = 0xBE9 // 3049 ++ SYS_LOG2D32 = 0xBEA // 3050 ++ SYS_LOG2D64 = 0xBEB // 3051 ++ SYS_LOG2D128 = 0xBEC // 3052 ++ SYS_LOGBD32 = 0xBED // 3053 ++ SYS_LOGBD64 = 0xBEE // 3054 ++ SYS_LOGBD128 = 0xBEF // 3055 ++ SYS_LRINTD32 = 0xBF0 // 3056 ++ SYS_LRINTD64 = 0xBF1 // 3057 ++ SYS_LRINTD128 = 0xBF2 // 3058 ++ SYS_LROUNDD32 = 0xBF3 // 3059 ++ SYS_LROUNDD64 = 0xBF4 // 3060 ++ SYS_LROUNDD128 = 0xBF5 // 3061 ++ SYS_MODFD32 = 0xBF6 // 3062 ++ SYS_MODFD64 = 0xBF7 // 3063 ++ SYS_MODFD128 = 0xBF8 // 3064 ++ SYS_NAND32 = 0xBF9 // 3065 ++ SYS_NAND64 = 0xBFA // 3066 ++ SYS_NAND128 = 0xBFB // 3067 ++ SYS_NEARBYINTD32 = 0xBFC // 3068 ++ SYS_NEARBYINTD64 = 0xBFD // 3069 ++ SYS_NEARBYINTD128 = 0xBFE // 3070 ++ SYS_NEXTAFTERD32 = 0xBFF // 3071 ++ SYS_NEXTAFTERD64 = 0xC00 // 3072 ++ SYS_NEXTAFTERD128 = 0xC01 // 3073 ++ SYS_NEXTTOWARDD32 = 0xC02 // 3074 ++ SYS_NEXTTOWARDD64 = 0xC03 // 3075 ++ SYS_NEXTTOWARDD128 = 0xC04 // 3076 ++ SYS_POWD32 = 0xC05 // 3077 ++ SYS_POWD64 = 0xC06 // 3078 ++ SYS_POWD128 = 0xC07 // 3079 ++ SYS_QUANTIZED32 = 0xC08 // 3080 ++ SYS_QUANTIZED64 = 0xC09 // 3081 ++ SYS_QUANTIZED128 = 0xC0A // 3082 ++ SYS_REMAINDERD32 = 0xC0B // 3083 ++ SYS_REMAINDERD64 = 0xC0C // 3084 ++ SYS_REMAINDERD128 = 0xC0D // 3085 ++ SYS___REMQUOD32 = 0xC0E // 3086 ++ SYS___REMQUOD64 = 0xC0F // 3087 ++ SYS___REMQUOD128 = 0xC10 // 3088 ++ SYS_RINTD32 = 0xC11 // 3089 ++ SYS_RINTD64 = 0xC12 // 3090 ++ SYS_RINTD128 = 0xC13 // 3091 ++ SYS_ROUNDD32 = 0xC14 // 3092 ++ SYS_ROUNDD64 = 0xC15 // 3093 ++ SYS_ROUNDD128 = 0xC16 // 3094 ++ SYS_SAMEQUANTUMD32 = 0xC17 // 3095 ++ SYS_SAMEQUANTUMD64 = 0xC18 // 3096 ++ SYS_SAMEQUANTUMD128 = 0xC19 // 3097 ++ SYS_SCALBLND32 = 0xC1A // 3098 ++ SYS_SCALBLND64 = 0xC1B // 3099 ++ SYS_SCALBLND128 = 0xC1C // 3100 ++ SYS_SCALBND32 = 0xC1D // 3101 ++ SYS_SCALBND64 = 0xC1E // 3102 ++ SYS_SCALBND128 = 0xC1F // 3103 ++ SYS_SIND32 = 0xC20 // 3104 ++ SYS_SIND64 = 0xC21 // 3105 ++ SYS_SIND128 = 0xC22 // 3106 ++ SYS_SINHD32 = 0xC23 // 3107 ++ SYS_SINHD64 = 0xC24 // 3108 ++ SYS_SINHD128 = 0xC25 // 3109 ++ SYS_SQRTD32 = 0xC26 // 3110 ++ SYS_SQRTD64 = 0xC27 // 3111 ++ SYS_SQRTD128 = 0xC28 // 3112 ++ SYS_STRTOD32 = 0xC29 // 3113 ++ SYS_STRTOD64 = 0xC2A // 3114 ++ SYS_STRTOD128 = 0xC2B // 3115 ++ SYS_TAND32 = 0xC2C // 3116 ++ SYS_TAND64 = 0xC2D // 3117 ++ SYS_TAND128 = 0xC2E // 3118 ++ SYS_TANHD32 = 0xC2F // 3119 ++ SYS_TANHD64 = 0xC30 // 3120 ++ SYS_TANHD128 = 0xC31 // 3121 ++ SYS_TGAMMAD32 = 0xC32 // 3122 ++ SYS_TGAMMAD64 = 0xC33 // 3123 ++ SYS_TGAMMAD128 = 0xC34 // 3124 ++ SYS_TRUNCD32 = 0xC3E // 3134 ++ SYS_TRUNCD64 = 0xC3F // 3135 ++ SYS_TRUNCD128 = 0xC40 // 3136 ++ SYS_WCSTOD32 = 0xC41 // 3137 ++ SYS_WCSTOD64 = 0xC42 // 3138 ++ SYS_WCSTOD128 = 0xC43 // 3139 ++ SYS___CODEPAGE_INFO = 0xC64 // 3172 ++ SYS_POSIX_OPENPT = 0xC66 // 3174 ++ SYS_PSELECT = 0xC67 // 3175 ++ SYS_SOCKATMARK = 0xC68 // 3176 ++ SYS_AIO_FSYNC = 0xC69 // 3177 ++ SYS_LIO_LISTIO = 0xC6A // 3178 ++ SYS___ATANPID32 = 0xC6B // 3179 ++ SYS___ATANPID64 = 0xC6C // 3180 ++ SYS___ATANPID128 = 0xC6D // 3181 ++ SYS___COSPID32 = 0xC6E // 3182 ++ SYS___COSPID64 = 0xC6F // 3183 ++ SYS___COSPID128 = 0xC70 // 3184 ++ SYS___SINPID32 = 0xC71 // 3185 ++ SYS___SINPID64 = 0xC72 // 3186 ++ SYS___SINPID128 = 0xC73 // 3187 ++ SYS_SETIPV4SOURCEFILTER = 0xC76 // 3190 ++ SYS_GETIPV4SOURCEFILTER = 0xC77 // 3191 ++ SYS_SETSOURCEFILTER = 0xC78 // 3192 ++ SYS_GETSOURCEFILTER = 0xC79 // 3193 ++ SYS_FWRITE_UNLOCKED = 0xC7A // 3194 ++ SYS_FREAD_UNLOCKED = 0xC7B // 3195 ++ SYS_FGETS_UNLOCKED = 0xC7C // 3196 ++ SYS_GETS_UNLOCKED = 0xC7D // 3197 ++ SYS_FPUTS_UNLOCKED = 0xC7E // 3198 ++ SYS_PUTS_UNLOCKED = 0xC7F // 3199 ++ SYS_FGETC_UNLOCKED = 0xC80 // 3200 ++ SYS_FPUTC_UNLOCKED = 0xC81 // 3201 ++ SYS_DLADDR = 0xC82 // 3202 ++ SYS_SHM_OPEN = 0xC8C // 3212 ++ SYS_SHM_UNLINK = 0xC8D // 3213 ++ SYS___CLASS2F = 0xC91 // 3217 ++ SYS___CLASS2L = 0xC92 // 3218 ++ SYS___CLASS2F_B = 0xC93 // 3219 ++ SYS___CLASS2F_H = 0xC94 // 3220 ++ SYS___CLASS2L_B = 0xC95 // 3221 ++ SYS___CLASS2L_H = 0xC96 // 3222 ++ SYS___CLASS2D32 = 0xC97 // 3223 ++ SYS___CLASS2D64 = 0xC98 // 3224 ++ SYS___CLASS2D128 = 0xC99 // 3225 ++ SYS___TOCSNAME2 = 0xC9A // 3226 ++ SYS___D1TOP = 0xC9B // 3227 ++ SYS___D2TOP = 0xC9C // 3228 ++ SYS___D4TOP = 0xC9D // 3229 ++ SYS___PTOD1 = 0xC9E // 3230 ++ SYS___PTOD2 = 0xC9F // 3231 ++ SYS___PTOD4 = 0xCA0 // 3232 ++ SYS_CLEARERR_UNLOCKED = 0xCA1 // 3233 ++ SYS_FDELREC_UNLOCKED = 0xCA2 // 3234 ++ SYS_FEOF_UNLOCKED = 0xCA3 // 3235 ++ SYS_FERROR_UNLOCKED = 0xCA4 // 3236 ++ SYS_FFLUSH_UNLOCKED = 0xCA5 // 3237 ++ SYS_FGETPOS_UNLOCKED = 0xCA6 // 3238 ++ SYS_FGETWC_UNLOCKED = 0xCA7 // 3239 ++ SYS_FGETWS_UNLOCKED = 0xCA8 // 3240 ++ SYS_FILENO_UNLOCKED = 0xCA9 // 3241 ++ SYS_FLDATA_UNLOCKED = 0xCAA // 3242 ++ SYS_FLOCATE_UNLOCKED = 0xCAB // 3243 ++ SYS_FPRINTF_UNLOCKED = 0xCAC // 3244 ++ SYS_FPUTWC_UNLOCKED = 0xCAD // 3245 ++ SYS_FPUTWS_UNLOCKED = 0xCAE // 3246 ++ SYS_FSCANF_UNLOCKED = 0xCAF // 3247 ++ SYS_FSEEK_UNLOCKED = 0xCB0 // 3248 ++ SYS_FSEEKO_UNLOCKED = 0xCB1 // 3249 ++ SYS_FSETPOS_UNLOCKED = 0xCB3 // 3251 ++ SYS_FTELL_UNLOCKED = 0xCB4 // 3252 ++ SYS_FTELLO_UNLOCKED = 0xCB5 // 3253 ++ SYS_FUPDATE_UNLOCKED = 0xCB7 // 3255 ++ SYS_FWIDE_UNLOCKED = 0xCB8 // 3256 ++ SYS_FWPRINTF_UNLOCKED = 0xCB9 // 3257 ++ SYS_FWSCANF_UNLOCKED = 0xCBA // 3258 ++ SYS_GETWC_UNLOCKED = 0xCBB // 3259 ++ SYS_GETWCHAR_UNLOCKED = 0xCBC // 3260 ++ SYS_PERROR_UNLOCKED = 0xCBD // 3261 ++ SYS_PRINTF_UNLOCKED = 0xCBE // 3262 ++ SYS_PUTWC_UNLOCKED = 0xCBF // 3263 ++ SYS_PUTWCHAR_UNLOCKED = 0xCC0 // 3264 ++ SYS_REWIND_UNLOCKED = 0xCC1 // 3265 ++ SYS_SCANF_UNLOCKED = 0xCC2 // 3266 ++ SYS_UNGETC_UNLOCKED = 0xCC3 // 3267 ++ SYS_UNGETWC_UNLOCKED = 0xCC4 // 3268 ++ SYS_VFPRINTF_UNLOCKED = 0xCC5 // 3269 ++ SYS_VFSCANF_UNLOCKED = 0xCC7 // 3271 ++ SYS_VFWPRINTF_UNLOCKED = 0xCC9 // 3273 ++ SYS_VFWSCANF_UNLOCKED = 0xCCB // 3275 ++ SYS_VPRINTF_UNLOCKED = 0xCCD // 3277 ++ SYS_VSCANF_UNLOCKED = 0xCCF // 3279 ++ SYS_VWPRINTF_UNLOCKED = 0xCD1 // 3281 ++ SYS_VWSCANF_UNLOCKED = 0xCD3 // 3283 ++ SYS_WPRINTF_UNLOCKED = 0xCD5 // 3285 ++ SYS_WSCANF_UNLOCKED = 0xCD6 // 3286 ++ SYS_ASCTIME64 = 0xCD7 // 3287 ++ SYS_ASCTIME64_R = 0xCD8 // 3288 ++ SYS_CTIME64 = 0xCD9 // 3289 ++ SYS_CTIME64_R = 0xCDA // 3290 ++ SYS_DIFFTIME64 = 0xCDB // 3291 ++ SYS_GMTIME64 = 0xCDC // 3292 ++ SYS_GMTIME64_R = 0xCDD // 3293 ++ SYS_LOCALTIME64 = 0xCDE // 3294 ++ SYS_LOCALTIME64_R = 0xCDF // 3295 ++ SYS_MKTIME64 = 0xCE0 // 3296 ++ SYS_TIME64 = 0xCE1 // 3297 ++ SYS___LOGIN_APPLID = 0xCE2 // 3298 ++ SYS___PASSWD_APPLID = 0xCE3 // 3299 ++ SYS_PTHREAD_SECURITY_APPLID_NP = 0xCE4 // 3300 ++ SYS___GETTHENT = 0xCE5 // 3301 ++ SYS_FREEIFADDRS = 0xCE6 // 3302 ++ SYS_GETIFADDRS = 0xCE7 // 3303 ++ SYS_POSIX_FALLOCATE = 0xCE8 // 3304 ++ SYS_POSIX_MEMALIGN = 0xCE9 // 3305 ++ SYS_SIZEOF_ALLOC = 0xCEA // 3306 ++ SYS_RESIZE_ALLOC = 0xCEB // 3307 ++ SYS_FREAD_NOUPDATE = 0xCEC // 3308 ++ SYS_FREAD_NOUPDATE_UNLOCKED = 0xCED // 3309 ++ SYS_FGETPOS64 = 0xCEE // 3310 ++ SYS_FSEEK64 = 0xCEF // 3311 ++ SYS_FSEEKO64 = 0xCF0 // 3312 ++ SYS_FSETPOS64 = 0xCF1 // 3313 ++ SYS_FTELL64 = 0xCF2 // 3314 ++ SYS_FTELLO64 = 0xCF3 // 3315 ++ SYS_FGETPOS64_UNLOCKED = 0xCF4 // 3316 ++ SYS_FSEEK64_UNLOCKED = 0xCF5 // 3317 ++ SYS_FSEEKO64_UNLOCKED = 0xCF6 // 3318 ++ SYS_FSETPOS64_UNLOCKED = 0xCF7 // 3319 ++ SYS_FTELL64_UNLOCKED = 0xCF8 // 3320 ++ SYS_FTELLO64_UNLOCKED = 0xCF9 // 3321 ++ SYS_FOPEN_UNLOCKED = 0xCFA // 3322 ++ SYS_FREOPEN_UNLOCKED = 0xCFB // 3323 ++ SYS_FDOPEN_UNLOCKED = 0xCFC // 3324 ++ SYS_TMPFILE_UNLOCKED = 0xCFD // 3325 ++ SYS___MOSERVICES = 0xD3D // 3389 ++ SYS___GETTOD = 0xD3E // 3390 ++ SYS_C16RTOMB = 0xD40 // 3392 ++ SYS_C32RTOMB = 0xD41 // 3393 ++ SYS_MBRTOC16 = 0xD42 // 3394 ++ SYS_MBRTOC32 = 0xD43 // 3395 ++ SYS_QUANTEXPD32 = 0xD44 // 3396 ++ SYS_QUANTEXPD64 = 0xD45 // 3397 ++ SYS_QUANTEXPD128 = 0xD46 // 3398 ++ SYS___LOCALE_CTL = 0xD47 // 3399 ++ SYS___SMF_RECORD2 = 0xD48 // 3400 ++ SYS_FOPEN64 = 0xD49 // 3401 ++ SYS_FOPEN64_UNLOCKED = 0xD4A // 3402 ++ SYS_FREOPEN64 = 0xD4B // 3403 ++ SYS_FREOPEN64_UNLOCKED = 0xD4C // 3404 ++ SYS_TMPFILE64 = 0xD4D // 3405 ++ SYS_TMPFILE64_UNLOCKED = 0xD4E // 3406 ++ SYS_GETDATE64 = 0xD4F // 3407 ++ SYS_GETTIMEOFDAY64 = 0xD50 // 3408 ++ SYS_BIND2ADDRSEL = 0xD59 // 3417 ++ SYS_INET6_IS_SRCADDR = 0xD5A // 3418 ++ SYS___GETGRGID1 = 0xD5B // 3419 ++ SYS___GETGRNAM1 = 0xD5C // 3420 ++ SYS___FBUFSIZE = 0xD60 // 3424 ++ SYS___FPENDING = 0xD61 // 3425 ++ SYS___FLBF = 0xD62 // 3426 ++ SYS___FREADABLE = 0xD63 // 3427 ++ SYS___FWRITABLE = 0xD64 // 3428 ++ SYS___FREADING = 0xD65 // 3429 ++ SYS___FWRITING = 0xD66 // 3430 ++ SYS___FSETLOCKING = 0xD67 // 3431 ++ SYS__FLUSHLBF = 0xD68 // 3432 ++ SYS___FPURGE = 0xD69 // 3433 ++ SYS___FREADAHEAD = 0xD6A // 3434 ++ SYS___FSETERR = 0xD6B // 3435 ++ SYS___FPENDING_UNLOCKED = 0xD6C // 3436 ++ SYS___FREADING_UNLOCKED = 0xD6D // 3437 ++ SYS___FWRITING_UNLOCKED = 0xD6E // 3438 ++ SYS__FLUSHLBF_UNLOCKED = 0xD6F // 3439 ++ SYS___FPURGE_UNLOCKED = 0xD70 // 3440 ++ SYS___FREADAHEAD_UNLOCKED = 0xD71 // 3441 ++ SYS___LE_CEEGTJS = 0xD72 // 3442 ++ SYS___LE_RECORD_DUMP = 0xD73 // 3443 ++ SYS_FSTAT64 = 0xD74 // 3444 ++ SYS_LSTAT64 = 0xD75 // 3445 ++ SYS_STAT64 = 0xD76 // 3446 ++ SYS___READDIR2_64 = 0xD77 // 3447 ++ SYS___OPEN_STAT64 = 0xD78 // 3448 ++ SYS_FTW64 = 0xD79 // 3449 ++ SYS_NFTW64 = 0xD7A // 3450 ++ SYS_UTIME64 = 0xD7B // 3451 ++ SYS_UTIMES64 = 0xD7C // 3452 ++ SYS___GETIPC64 = 0xD7D // 3453 ++ SYS_MSGCTL64 = 0xD7E // 3454 ++ SYS_SEMCTL64 = 0xD7F // 3455 ++ SYS_SHMCTL64 = 0xD80 // 3456 ++ SYS_MSGXRCV64 = 0xD81 // 3457 ++ SYS___MGXR64 = 0xD81 // 3457 ++ SYS_W_GETPSENT64 = 0xD82 // 3458 ++ SYS_PTHREAD_COND_TIMEDWAIT64 = 0xD83 // 3459 ++ SYS_FTIME64 = 0xD85 // 3461 ++ SYS_GETUTXENT64 = 0xD86 // 3462 ++ SYS_GETUTXID64 = 0xD87 // 3463 ++ SYS_GETUTXLINE64 = 0xD88 // 3464 ++ SYS_PUTUTXLINE64 = 0xD89 // 3465 ++ SYS_NEWLOCALE = 0xD8A // 3466 ++ SYS_FREELOCALE = 0xD8B // 3467 ++ SYS_USELOCALE = 0xD8C // 3468 ++ SYS_DUPLOCALE = 0xD8D // 3469 ++ SYS___CHATTR64 = 0xD9C // 3484 ++ SYS___LCHATTR64 = 0xD9D // 3485 ++ SYS___FCHATTR64 = 0xD9E // 3486 ++ SYS_____CHATTR64_A = 0xD9F // 3487 ++ SYS_____LCHATTR64_A = 0xDA0 // 3488 ++ SYS___LE_CEEUSGD = 0xDA1 // 3489 ++ SYS___LE_IFAM_CON = 0xDA2 // 3490 ++ SYS___LE_IFAM_DSC = 0xDA3 // 3491 ++ SYS___LE_IFAM_GET = 0xDA4 // 3492 ++ SYS___LE_IFAM_QRY = 0xDA5 // 3493 ++ SYS_ALIGNED_ALLOC = 0xDA6 // 3494 ++ SYS_ACCEPT4 = 0xDA7 // 3495 ++ SYS___ACCEPT4_A = 0xDA8 // 3496 ++ SYS_COPYFILERANGE = 0xDA9 // 3497 ++ SYS_GETLINE = 0xDAA // 3498 ++ SYS___GETLINE_A = 0xDAB // 3499 ++ SYS_DIRFD = 0xDAC // 3500 ++ SYS_CLOCK_GETTIME = 0xDAD // 3501 ++ SYS_DUP3 = 0xDAE // 3502 ++ SYS_EPOLL_CREATE = 0xDAF // 3503 ++ SYS_EPOLL_CREATE1 = 0xDB0 // 3504 ++ SYS_EPOLL_CTL = 0xDB1 // 3505 ++ SYS_EPOLL_WAIT = 0xDB2 // 3506 ++ SYS_EPOLL_PWAIT = 0xDB3 // 3507 ++ SYS_EVENTFD = 0xDB4 // 3508 ++ SYS_STATFS = 0xDB5 // 3509 ++ SYS___STATFS_A = 0xDB6 // 3510 ++ SYS_FSTATFS = 0xDB7 // 3511 ++ SYS_INOTIFY_INIT = 0xDB8 // 3512 ++ SYS_INOTIFY_INIT1 = 0xDB9 // 3513 ++ SYS_INOTIFY_ADD_WATCH = 0xDBA // 3514 ++ SYS___INOTIFY_ADD_WATCH_A = 0xDBB // 3515 ++ SYS_INOTIFY_RM_WATCH = 0xDBC // 3516 ++ SYS_PIPE2 = 0xDBD // 3517 ++ SYS_PIVOT_ROOT = 0xDBE // 3518 ++ SYS___PIVOT_ROOT_A = 0xDBF // 3519 ++ SYS_PRCTL = 0xDC0 // 3520 ++ SYS_PRLIMIT = 0xDC1 // 3521 ++ SYS_SETHOSTNAME = 0xDC2 // 3522 ++ SYS___SETHOSTNAME_A = 0xDC3 // 3523 ++ SYS_SETRESUID = 0xDC4 // 3524 ++ SYS_SETRESGID = 0xDC5 // 3525 ++ SYS_PTHREAD_CONDATTR_GETCLOCK = 0xDC6 // 3526 ++ SYS_FLOCK = 0xDC7 // 3527 ++ SYS_FGETXATTR = 0xDC8 // 3528 ++ SYS___FGETXATTR_A = 0xDC9 // 3529 ++ SYS_FLISTXATTR = 0xDCA // 3530 ++ SYS___FLISTXATTR_A = 0xDCB // 3531 ++ SYS_FREMOVEXATTR = 0xDCC // 3532 ++ SYS___FREMOVEXATTR_A = 0xDCD // 3533 ++ SYS_FSETXATTR = 0xDCE // 3534 ++ SYS___FSETXATTR_A = 0xDCF // 3535 ++ SYS_GETXATTR = 0xDD0 // 3536 ++ SYS___GETXATTR_A = 0xDD1 // 3537 ++ SYS_LGETXATTR = 0xDD2 // 3538 ++ SYS___LGETXATTR_A = 0xDD3 // 3539 ++ SYS_LISTXATTR = 0xDD4 // 3540 ++ SYS___LISTXATTR_A = 0xDD5 // 3541 ++ SYS_LLISTXATTR = 0xDD6 // 3542 ++ SYS___LLISTXATTR_A = 0xDD7 // 3543 ++ SYS_LREMOVEXATTR = 0xDD8 // 3544 ++ SYS___LREMOVEXATTR_A = 0xDD9 // 3545 ++ SYS_LSETXATTR = 0xDDA // 3546 ++ SYS___LSETXATTR_A = 0xDDB // 3547 ++ SYS_REMOVEXATTR = 0xDDC // 3548 ++ SYS___REMOVEXATTR_A = 0xDDD // 3549 ++ SYS_SETXATTR = 0xDDE // 3550 ++ SYS___SETXATTR_A = 0xDDF // 3551 ++ SYS_FDATASYNC = 0xDE0 // 3552 ++ SYS_SYNCFS = 0xDE1 // 3553 ++ SYS_FUTIMES = 0xDE2 // 3554 ++ SYS_FUTIMESAT = 0xDE3 // 3555 ++ SYS___FUTIMESAT_A = 0xDE4 // 3556 ++ SYS_LUTIMES = 0xDE5 // 3557 ++ SYS___LUTIMES_A = 0xDE6 // 3558 ++ SYS_INET_ATON = 0xDE7 // 3559 ++ SYS_GETRANDOM = 0xDE8 // 3560 ++ SYS_GETTID = 0xDE9 // 3561 ++ SYS_MEMFD_CREATE = 0xDEA // 3562 ++ SYS___MEMFD_CREATE_A = 0xDEB // 3563 ++ SYS_FACCESSAT = 0xDEC // 3564 ++ SYS___FACCESSAT_A = 0xDED // 3565 ++ SYS_FCHMODAT = 0xDEE // 3566 ++ SYS___FCHMODAT_A = 0xDEF // 3567 ++ SYS_FCHOWNAT = 0xDF0 // 3568 ++ SYS___FCHOWNAT_A = 0xDF1 // 3569 ++ SYS_FSTATAT = 0xDF2 // 3570 ++ SYS___FSTATAT_A = 0xDF3 // 3571 ++ SYS_LINKAT = 0xDF4 // 3572 ++ SYS___LINKAT_A = 0xDF5 // 3573 ++ SYS_MKDIRAT = 0xDF6 // 3574 ++ SYS___MKDIRAT_A = 0xDF7 // 3575 ++ SYS_MKFIFOAT = 0xDF8 // 3576 ++ SYS___MKFIFOAT_A = 0xDF9 // 3577 ++ SYS_MKNODAT = 0xDFA // 3578 ++ SYS___MKNODAT_A = 0xDFB // 3579 ++ SYS_OPENAT = 0xDFC // 3580 ++ SYS___OPENAT_A = 0xDFD // 3581 ++ SYS_READLINKAT = 0xDFE // 3582 ++ SYS___READLINKAT_A = 0xDFF // 3583 ++ SYS_RENAMEAT = 0xE00 // 3584 ++ SYS___RENAMEAT_A = 0xE01 // 3585 ++ SYS_RENAMEAT2 = 0xE02 // 3586 ++ SYS___RENAMEAT2_A = 0xE03 // 3587 ++ SYS_SYMLINKAT = 0xE04 // 3588 ++ SYS___SYMLINKAT_A = 0xE05 // 3589 ++ SYS_UNLINKAT = 0xE06 // 3590 ++ SYS___UNLINKAT_A = 0xE07 // 3591 ++ SYS_SYSINFO = 0xE08 // 3592 ++ SYS_WAIT4 = 0xE0A // 3594 ++ SYS_CLONE = 0xE0B // 3595 ++ SYS_UNSHARE = 0xE0C // 3596 ++ SYS_SETNS = 0xE0D // 3597 ++ SYS_CAPGET = 0xE0E // 3598 ++ SYS_CAPSET = 0xE0F // 3599 ++ SYS_STRCHRNUL = 0xE10 // 3600 ++ SYS_PTHREAD_CONDATTR_SETCLOCK = 0xE12 // 3602 ++ SYS_OPEN_BY_HANDLE_AT = 0xE13 // 3603 ++ SYS___OPEN_BY_HANDLE_AT_A = 0xE14 // 3604 ++ SYS___INET_ATON_A = 0xE15 // 3605 ++ SYS_MOUNT1 = 0xE16 // 3606 ++ SYS___MOUNT1_A = 0xE17 // 3607 ++ SYS_UMOUNT1 = 0xE18 // 3608 ++ SYS___UMOUNT1_A = 0xE19 // 3609 ++ SYS_UMOUNT2 = 0xE1A // 3610 ++ SYS___UMOUNT2_A = 0xE1B // 3611 ++ SYS___PRCTL_A = 0xE1C // 3612 ++ SYS_LOCALTIME_R2 = 0xE1D // 3613 ++ SYS___LOCALTIME_R2_A = 0xE1E // 3614 ++ SYS_OPENAT2 = 0xE1F // 3615 ++ SYS___OPENAT2_A = 0xE20 // 3616 ++ SYS___LE_CEEMICT = 0xE21 // 3617 ++ SYS_GETENTROPY = 0xE22 // 3618 ++ SYS_NANOSLEEP = 0xE23 // 3619 ++ SYS_UTIMENSAT = 0xE24 // 3620 ++ SYS___UTIMENSAT_A = 0xE25 // 3621 ++ SYS_ASPRINTF = 0xE26 // 3622 ++ SYS___ASPRINTF_A = 0xE27 // 3623 ++ SYS_VASPRINTF = 0xE28 // 3624 ++ SYS___VASPRINTF_A = 0xE29 // 3625 ++ SYS_DPRINTF = 0xE2A // 3626 ++ SYS___DPRINTF_A = 0xE2B // 3627 ++ SYS_GETOPT_LONG = 0xE2C // 3628 ++ SYS___GETOPT_LONG_A = 0xE2D // 3629 ++ SYS_PSIGNAL = 0xE2E // 3630 ++ SYS___PSIGNAL_A = 0xE2F // 3631 ++ SYS_PSIGNAL_UNLOCKED = 0xE30 // 3632 ++ SYS___PSIGNAL_UNLOCKED_A = 0xE31 // 3633 ++ SYS_FSTATAT_O = 0xE32 // 3634 ++ SYS___FSTATAT_O_A = 0xE33 // 3635 ++ SYS_FSTATAT64 = 0xE34 // 3636 ++ SYS___FSTATAT64_A = 0xE35 // 3637 ++ SYS___CHATTRAT = 0xE36 // 3638 ++ SYS_____CHATTRAT_A = 0xE37 // 3639 ++ SYS___CHATTRAT64 = 0xE38 // 3640 ++ SYS_____CHATTRAT64_A = 0xE39 // 3641 ++ SYS_MADVISE = 0xE3A // 3642 ++ SYS___AUTHENTICATE = 0xE3B // 3643 ++ + ) +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go +index dc0c955eecdf..4740b834854b 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go +@@ -836,6 +836,15 @@ const ( + FSPICK_EMPTY_PATH = 0x8 + + FSMOUNT_CLOEXEC = 0x1 ++ ++ FSCONFIG_SET_FLAG = 0x0 ++ FSCONFIG_SET_STRING = 0x1 ++ FSCONFIG_SET_BINARY = 0x2 ++ FSCONFIG_SET_PATH = 0x3 ++ FSCONFIG_SET_PATH_EMPTY = 0x4 ++ FSCONFIG_SET_FD = 0x5 ++ FSCONFIG_CMD_CREATE = 0x6 ++ FSCONFIG_CMD_RECONFIGURE = 0x7 + ) + + type OpenHow struct { +@@ -1169,7 +1178,8 @@ const ( + PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT = 0x10 + PERF_SAMPLE_BRANCH_HW_INDEX_SHIFT = 0x11 + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 0x12 +- PERF_SAMPLE_BRANCH_MAX_SHIFT = 0x13 ++ PERF_SAMPLE_BRANCH_COUNTERS = 0x80000 ++ PERF_SAMPLE_BRANCH_MAX_SHIFT = 0x14 + PERF_SAMPLE_BRANCH_USER = 0x1 + PERF_SAMPLE_BRANCH_KERNEL = 0x2 + PERF_SAMPLE_BRANCH_HV = 0x4 +@@ -1189,7 +1199,7 @@ const ( + PERF_SAMPLE_BRANCH_TYPE_SAVE = 0x10000 + PERF_SAMPLE_BRANCH_HW_INDEX = 0x20000 + PERF_SAMPLE_BRANCH_PRIV_SAVE = 0x40000 +- PERF_SAMPLE_BRANCH_MAX = 0x80000 ++ PERF_SAMPLE_BRANCH_MAX = 0x100000 + PERF_BR_UNKNOWN = 0x0 + PERF_BR_COND = 0x1 + PERF_BR_UNCOND = 0x2 +@@ -1550,6 +1560,7 @@ const ( + IFLA_DEVLINK_PORT = 0x3e + IFLA_GSO_IPV4_MAX_SIZE = 0x3f + IFLA_GRO_IPV4_MAX_SIZE = 0x40 ++ IFLA_DPLL_PIN = 0x41 + IFLA_PROTO_DOWN_REASON_UNSPEC = 0x0 + IFLA_PROTO_DOWN_REASON_MASK = 0x1 + IFLA_PROTO_DOWN_REASON_VALUE = 0x2 +@@ -1565,6 +1576,7 @@ const ( + IFLA_INET6_ICMP6STATS = 0x6 + IFLA_INET6_TOKEN = 0x7 + IFLA_INET6_ADDR_GEN_MODE = 0x8 ++ IFLA_INET6_RA_MTU = 0x9 + IFLA_BR_UNSPEC = 0x0 + IFLA_BR_FORWARD_DELAY = 0x1 + IFLA_BR_HELLO_TIME = 0x2 +@@ -1612,6 +1624,9 @@ const ( + IFLA_BR_MCAST_MLD_VERSION = 0x2c + IFLA_BR_VLAN_STATS_PER_PORT = 0x2d + IFLA_BR_MULTI_BOOLOPT = 0x2e ++ IFLA_BR_MCAST_QUERIER_STATE = 0x2f ++ IFLA_BR_FDB_N_LEARNED = 0x30 ++ IFLA_BR_FDB_MAX_LEARNED = 0x31 + IFLA_BRPORT_UNSPEC = 0x0 + IFLA_BRPORT_STATE = 0x1 + IFLA_BRPORT_PRIORITY = 0x2 +@@ -1649,6 +1664,14 @@ const ( + IFLA_BRPORT_BACKUP_PORT = 0x22 + IFLA_BRPORT_MRP_RING_OPEN = 0x23 + IFLA_BRPORT_MRP_IN_OPEN = 0x24 ++ IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT = 0x25 ++ IFLA_BRPORT_MCAST_EHT_HOSTS_CNT = 0x26 ++ IFLA_BRPORT_LOCKED = 0x27 ++ IFLA_BRPORT_MAB = 0x28 ++ IFLA_BRPORT_MCAST_N_GROUPS = 0x29 ++ IFLA_BRPORT_MCAST_MAX_GROUPS = 0x2a ++ IFLA_BRPORT_NEIGH_VLAN_SUPPRESS = 0x2b ++ IFLA_BRPORT_BACKUP_NHID = 0x2c + IFLA_INFO_UNSPEC = 0x0 + IFLA_INFO_KIND = 0x1 + IFLA_INFO_DATA = 0x2 +@@ -1670,6 +1693,9 @@ const ( + IFLA_MACVLAN_MACADDR = 0x4 + IFLA_MACVLAN_MACADDR_DATA = 0x5 + IFLA_MACVLAN_MACADDR_COUNT = 0x6 ++ IFLA_MACVLAN_BC_QUEUE_LEN = 0x7 ++ IFLA_MACVLAN_BC_QUEUE_LEN_USED = 0x8 ++ IFLA_MACVLAN_BC_CUTOFF = 0x9 + IFLA_VRF_UNSPEC = 0x0 + IFLA_VRF_TABLE = 0x1 + IFLA_VRF_PORT_UNSPEC = 0x0 +@@ -1693,9 +1719,22 @@ const ( + IFLA_XFRM_UNSPEC = 0x0 + IFLA_XFRM_LINK = 0x1 + IFLA_XFRM_IF_ID = 0x2 ++ IFLA_XFRM_COLLECT_METADATA = 0x3 + IFLA_IPVLAN_UNSPEC = 0x0 + IFLA_IPVLAN_MODE = 0x1 + IFLA_IPVLAN_FLAGS = 0x2 ++ NETKIT_NEXT = -0x1 ++ NETKIT_PASS = 0x0 ++ NETKIT_DROP = 0x2 ++ NETKIT_REDIRECT = 0x7 ++ NETKIT_L2 = 0x0 ++ NETKIT_L3 = 0x1 ++ IFLA_NETKIT_UNSPEC = 0x0 ++ IFLA_NETKIT_PEER_INFO = 0x1 ++ IFLA_NETKIT_PRIMARY = 0x2 ++ IFLA_NETKIT_POLICY = 0x3 ++ IFLA_NETKIT_PEER_POLICY = 0x4 ++ IFLA_NETKIT_MODE = 0x5 + IFLA_VXLAN_UNSPEC = 0x0 + IFLA_VXLAN_ID = 0x1 + IFLA_VXLAN_GROUP = 0x2 +@@ -1726,6 +1765,8 @@ const ( + IFLA_VXLAN_GPE = 0x1b + IFLA_VXLAN_TTL_INHERIT = 0x1c + IFLA_VXLAN_DF = 0x1d ++ IFLA_VXLAN_VNIFILTER = 0x1e ++ IFLA_VXLAN_LOCALBYPASS = 0x1f + IFLA_GENEVE_UNSPEC = 0x0 + IFLA_GENEVE_ID = 0x1 + IFLA_GENEVE_REMOTE = 0x2 +@@ -1740,6 +1781,7 @@ const ( + IFLA_GENEVE_LABEL = 0xb + IFLA_GENEVE_TTL_INHERIT = 0xc + IFLA_GENEVE_DF = 0xd ++ IFLA_GENEVE_INNER_PROTO_INHERIT = 0xe + IFLA_BAREUDP_UNSPEC = 0x0 + IFLA_BAREUDP_PORT = 0x1 + IFLA_BAREUDP_ETHERTYPE = 0x2 +@@ -1752,6 +1794,8 @@ const ( + IFLA_GTP_FD1 = 0x2 + IFLA_GTP_PDP_HASHSIZE = 0x3 + IFLA_GTP_ROLE = 0x4 ++ IFLA_GTP_CREATE_SOCKETS = 0x5 ++ IFLA_GTP_RESTART_COUNT = 0x6 + IFLA_BOND_UNSPEC = 0x0 + IFLA_BOND_MODE = 0x1 + IFLA_BOND_ACTIVE_SLAVE = 0x2 +@@ -1781,6 +1825,9 @@ const ( + IFLA_BOND_AD_ACTOR_SYSTEM = 0x1a + IFLA_BOND_TLB_DYNAMIC_LB = 0x1b + IFLA_BOND_PEER_NOTIF_DELAY = 0x1c ++ IFLA_BOND_AD_LACP_ACTIVE = 0x1d ++ IFLA_BOND_MISSED_MAX = 0x1e ++ IFLA_BOND_NS_IP6_TARGET = 0x1f + IFLA_BOND_AD_INFO_UNSPEC = 0x0 + IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 + IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 +@@ -1796,6 +1843,7 @@ const ( + IFLA_BOND_SLAVE_AD_AGGREGATOR_ID = 0x6 + IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE = 0x7 + IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE = 0x8 ++ IFLA_BOND_SLAVE_PRIO = 0x9 + IFLA_VF_INFO_UNSPEC = 0x0 + IFLA_VF_INFO = 0x1 + IFLA_VF_UNSPEC = 0x0 +@@ -1854,8 +1902,16 @@ const ( + IFLA_STATS_LINK_XSTATS_SLAVE = 0x3 + IFLA_STATS_LINK_OFFLOAD_XSTATS = 0x4 + IFLA_STATS_AF_SPEC = 0x5 ++ IFLA_STATS_GETSET_UNSPEC = 0x0 ++ IFLA_STATS_GET_FILTERS = 0x1 ++ IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS = 0x2 + IFLA_OFFLOAD_XSTATS_UNSPEC = 0x0 + IFLA_OFFLOAD_XSTATS_CPU_HIT = 0x1 ++ IFLA_OFFLOAD_XSTATS_HW_S_INFO = 0x2 ++ IFLA_OFFLOAD_XSTATS_L3_STATS = 0x3 ++ IFLA_OFFLOAD_XSTATS_HW_S_INFO_UNSPEC = 0x0 ++ IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST = 0x1 ++ IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED = 0x2 + IFLA_XDP_UNSPEC = 0x0 + IFLA_XDP_FD = 0x1 + IFLA_XDP_ATTACHED = 0x2 +@@ -1885,6 +1941,11 @@ const ( + IFLA_RMNET_UNSPEC = 0x0 + IFLA_RMNET_MUX_ID = 0x1 + IFLA_RMNET_FLAGS = 0x2 ++ IFLA_MCTP_UNSPEC = 0x0 ++ IFLA_MCTP_NET = 0x1 ++ IFLA_DSA_UNSPEC = 0x0 ++ IFLA_DSA_CONDUIT = 0x1 ++ IFLA_DSA_MASTER = 0x1 + ) + + const ( +@@ -2421,6 +2482,15 @@ type XDPMmapOffsets struct { + Cr XDPRingOffset + } + ++type XDPUmemReg struct { ++ Addr uint64 ++ Len uint64 ++ Chunk_size uint32 ++ Headroom uint32 ++ Flags uint32 ++ Tx_metadata_len uint32 ++} ++ + type XDPStatistics struct { + Rx_dropped uint64 + Rx_invalid_descs uint64 +@@ -2875,7 +2945,7 @@ const ( + BPF_TCP_LISTEN = 0xa + BPF_TCP_CLOSING = 0xb + BPF_TCP_NEW_SYN_RECV = 0xc +- BPF_TCP_MAX_STATES = 0xd ++ BPF_TCP_MAX_STATES = 0xe + TCP_BPF_IW = 0x3e9 + TCP_BPF_SNDCWND_CLAMP = 0x3ea + TCP_BPF_DELACK_MAX = 0x3eb +@@ -3151,7 +3221,7 @@ const ( + DEVLINK_CMD_LINECARD_NEW = 0x50 + DEVLINK_CMD_LINECARD_DEL = 0x51 + DEVLINK_CMD_SELFTESTS_GET = 0x52 +- DEVLINK_CMD_MAX = 0x53 ++ DEVLINK_CMD_MAX = 0x54 + DEVLINK_PORT_TYPE_NOTSET = 0x0 + DEVLINK_PORT_TYPE_AUTO = 0x1 + DEVLINK_PORT_TYPE_ETH = 0x2 +@@ -4535,7 +4605,7 @@ const ( + NL80211_ATTR_MAC_HINT = 0xc8 + NL80211_ATTR_MAC_MASK = 0xd7 + NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca +- NL80211_ATTR_MAX = 0x146 ++ NL80211_ATTR_MAX = 0x14a + NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 + NL80211_ATTR_MAX_CSA_COUNTERS = 0xce + NL80211_ATTR_MAX_MATCH_SETS = 0x85 +@@ -4801,7 +4871,7 @@ const ( + NL80211_BSS_FREQUENCY_OFFSET = 0x14 + NL80211_BSS_INFORMATION_ELEMENTS = 0x6 + NL80211_BSS_LAST_SEEN_BOOTTIME = 0xf +- NL80211_BSS_MAX = 0x16 ++ NL80211_BSS_MAX = 0x18 + NL80211_BSS_MLD_ADDR = 0x16 + NL80211_BSS_MLO_LINK_ID = 0x15 + NL80211_BSS_PAD = 0x10 +@@ -4905,7 +4975,7 @@ const ( + NL80211_CMD_LEAVE_IBSS = 0x2c + NL80211_CMD_LEAVE_MESH = 0x45 + NL80211_CMD_LEAVE_OCB = 0x6d +- NL80211_CMD_MAX = 0x9a ++ NL80211_CMD_MAX = 0x9b + NL80211_CMD_MICHAEL_MIC_FAILURE = 0x29 + NL80211_CMD_MODIFY_LINK_STA = 0x97 + NL80211_CMD_NAN_MATCH = 0x78 +@@ -5139,7 +5209,7 @@ const ( + NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf + NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe + NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf +- NL80211_FREQUENCY_ATTR_MAX = 0x1c ++ NL80211_FREQUENCY_ATTR_MAX = 0x20 + NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 + NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 + NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc +@@ -5633,7 +5703,7 @@ const ( + NL80211_STA_FLAG_ASSOCIATED = 0x7 + NL80211_STA_FLAG_AUTHENTICATED = 0x5 + NL80211_STA_FLAG_AUTHORIZED = 0x1 +- NL80211_STA_FLAG_MAX = 0x7 ++ NL80211_STA_FLAG_MAX = 0x8 + NL80211_STA_FLAG_MAX_OLD_API = 0x6 + NL80211_STA_FLAG_MFP = 0x4 + NL80211_STA_FLAG_SHORT_PREAMBLE = 0x2 +@@ -5931,3 +6001,34 @@ type CachestatRange struct { + Off uint64 + Len uint64 + } ++ ++const ( ++ SK_MEMINFO_RMEM_ALLOC = 0x0 ++ SK_MEMINFO_RCVBUF = 0x1 ++ SK_MEMINFO_WMEM_ALLOC = 0x2 ++ SK_MEMINFO_SNDBUF = 0x3 ++ SK_MEMINFO_FWD_ALLOC = 0x4 ++ SK_MEMINFO_WMEM_QUEUED = 0x5 ++ SK_MEMINFO_OPTMEM = 0x6 ++ SK_MEMINFO_BACKLOG = 0x7 ++ SK_MEMINFO_DROPS = 0x8 ++ SK_MEMINFO_VARS = 0x9 ++ SKNLGRP_NONE = 0x0 ++ SKNLGRP_INET_TCP_DESTROY = 0x1 ++ SKNLGRP_INET_UDP_DESTROY = 0x2 ++ SKNLGRP_INET6_TCP_DESTROY = 0x3 ++ SKNLGRP_INET6_UDP_DESTROY = 0x4 ++ SK_DIAG_BPF_STORAGE_REQ_NONE = 0x0 ++ SK_DIAG_BPF_STORAGE_REQ_MAP_FD = 0x1 ++ SK_DIAG_BPF_STORAGE_REP_NONE = 0x0 ++ SK_DIAG_BPF_STORAGE = 0x1 ++ SK_DIAG_BPF_STORAGE_NONE = 0x0 ++ SK_DIAG_BPF_STORAGE_PAD = 0x1 ++ SK_DIAG_BPF_STORAGE_MAP_ID = 0x2 ++ SK_DIAG_BPF_STORAGE_MAP_VALUE = 0x3 ++) ++ ++type SockDiagReq struct { ++ Family uint8 ++ Protocol uint8 ++} +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go +index 438a30affadc..fd402da43fce 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go +@@ -477,14 +477,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go +index adceca3553b6..eb7a5e1864ad 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go +@@ -492,15 +492,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go +index eeaa00a37d69..d78ac108b6c2 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go +@@ -470,15 +470,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]uint8 + Driver_name [64]uint8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go +index 6739aa91d4e2..cd06d47f1f7c 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go +@@ -471,15 +471,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go +index 9920ef6317d0..2f28fe26c1a5 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go +@@ -472,15 +472,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go +index 2923b799a48c..71d6cac2f1aa 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go +@@ -476,15 +476,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go +index ce2750ee415d..8596d4535638 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go +@@ -474,15 +474,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go +index 3038811d70bb..cd60ea18662b 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go +@@ -474,15 +474,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go +index efc6fed18c1f..b0ae420c489d 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go +@@ -476,15 +476,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go +index 9a654b75a90f..8359728759bc 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go +@@ -482,15 +482,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]uint8 + Driver_name [64]uint8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go +index 40d358e33e31..69eb6a5c6892 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go +@@ -481,15 +481,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]uint8 + Driver_name [64]uint8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go +index 148c6ceb869c..5f583cb62bf3 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go +@@ -481,15 +481,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]uint8 + Driver_name [64]uint8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +index 72ba81543ef7..15adc04142f2 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +@@ -499,15 +499,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]uint8 + Driver_name [64]uint8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go +index 71e765508e26..cf3ce9003770 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go +@@ -495,15 +495,6 @@ const ( + BLKPG = 0x1269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go +index 4abbdb9de932..590b56739c5b 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go +@@ -476,15 +476,6 @@ const ( + BLKPG = 0x20001269 + ) + +-type XDPUmemReg struct { +- Addr uint64 +- Len uint64 +- Size uint32 +- Headroom uint32 +- Flags uint32 +- _ [4]byte +-} +- + type CryptoUserAlg struct { + Name [64]int8 + Driver_name [64]int8 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +index 54f31be63737..d9a13af4684b 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +@@ -25,10 +25,13 @@ const ( + SizeofIPv6Mreq = 20 + SizeofICMPv6Filter = 32 + SizeofIPv6MTUInfo = 32 ++ SizeofInet4Pktinfo = 8 ++ SizeofInet6Pktinfo = 20 + SizeofLinger = 8 + SizeofSockaddrInet4 = 16 + SizeofSockaddrInet6 = 28 + SizeofTCPInfo = 0x68 ++ SizeofUcred = 12 + ) + + type ( +@@ -69,12 +72,17 @@ type Utimbuf struct { + } + + type Utsname struct { +- Sysname [65]byte +- Nodename [65]byte +- Release [65]byte +- Version [65]byte +- Machine [65]byte +- Domainname [65]byte ++ Sysname [16]byte ++ Nodename [32]byte ++ Release [8]byte ++ Version [8]byte ++ Machine [16]byte ++} ++ ++type Ucred struct { ++ Pid int32 ++ Uid uint32 ++ Gid uint32 + } + + type RawSockaddrInet4 struct { +@@ -325,7 +333,7 @@ type Statvfs_t struct { + } + + type Statfs_t struct { +- Type uint32 ++ Type uint64 + Bsize uint64 + Blocks uint64 + Bfree uint64 +@@ -336,6 +344,7 @@ type Statfs_t struct { + Namelen uint64 + Frsize uint64 + Flags uint64 ++ _ [4]uint64 + } + + type direntLE struct { +@@ -412,3 +421,126 @@ type W_Mntent struct { + Quiesceowner [8]byte + _ [38]byte + } ++ ++type EpollEvent struct { ++ Events uint32 ++ _ int32 ++ Fd int32 ++ Pad int32 ++} ++ ++type InotifyEvent struct { ++ Wd int32 ++ Mask uint32 ++ Cookie uint32 ++ Len uint32 ++ Name string ++} ++ ++const ( ++ SizeofInotifyEvent = 0x10 ++) ++ ++type ConsMsg2 struct { ++ Cm2Format uint16 ++ Cm2R1 uint16 ++ Cm2Msglength uint32 ++ Cm2Msg *byte ++ Cm2R2 [4]byte ++ Cm2R3 [4]byte ++ Cm2Routcde *uint32 ++ Cm2Descr *uint32 ++ Cm2Msgflag uint32 ++ Cm2Token uint32 ++ Cm2Msgid *uint32 ++ Cm2R4 [4]byte ++ Cm2DomToken uint32 ++ Cm2DomMsgid *uint32 ++ Cm2ModCartptr *byte ++ Cm2ModConsidptr *byte ++ Cm2MsgCart [8]byte ++ Cm2MsgConsid [4]byte ++ Cm2R5 [12]byte ++} ++ ++const ( ++ CC_modify = 1 ++ CC_stop = 2 ++ CONSOLE_FORMAT_2 = 2 ++ CONSOLE_FORMAT_3 = 3 ++ CONSOLE_HRDCPY = 0x80000000 ++) ++ ++type OpenHow struct { ++ Flags uint64 ++ Mode uint64 ++ Resolve uint64 ++} ++ ++const SizeofOpenHow = 0x18 ++ ++const ( ++ RESOLVE_CACHED = 0x20 ++ RESOLVE_BENEATH = 0x8 ++ RESOLVE_IN_ROOT = 0x10 ++ RESOLVE_NO_MAGICLINKS = 0x2 ++ RESOLVE_NO_SYMLINKS = 0x4 ++ RESOLVE_NO_XDEV = 0x1 ++) ++ ++type Siginfo struct { ++ Signo int32 ++ Errno int32 ++ Code int32 ++ Pid int32 ++ Uid uint32 ++ _ [44]byte ++} ++ ++type SysvIpcPerm struct { ++ Uid uint32 ++ Gid uint32 ++ Cuid uint32 ++ Cgid uint32 ++ Mode int32 ++} ++ ++type SysvShmDesc struct { ++ Perm SysvIpcPerm ++ _ [4]byte ++ Lpid int32 ++ Cpid int32 ++ Nattch uint32 ++ _ [4]byte ++ _ [4]byte ++ _ [4]byte ++ _ int32 ++ _ uint8 ++ _ uint8 ++ _ uint16 ++ _ *byte ++ Segsz uint64 ++ Atime Time_t ++ Dtime Time_t ++ Ctime Time_t ++} ++ ++type SysvShmDesc64 struct { ++ Perm SysvIpcPerm ++ _ [4]byte ++ Lpid int32 ++ Cpid int32 ++ Nattch uint32 ++ _ [4]byte ++ _ [4]byte ++ _ [4]byte ++ _ int32 ++ _ byte ++ _ uint8 ++ _ uint16 ++ _ *byte ++ Segsz uint64 ++ Atime int64 ++ Dtime int64 ++ Ctime int64 ++} +diff --git a/vendor/golang.org/x/sys/windows/aliases.go b/vendor/golang.org/x/sys/windows/aliases.go +index ce2d713d62e4..16f90560a23a 100644 +--- a/vendor/golang.org/x/sys/windows/aliases.go ++++ b/vendor/golang.org/x/sys/windows/aliases.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build windows && go1.9 ++//go:build windows + + package windows + +diff --git a/vendor/golang.org/x/sys/windows/empty.s b/vendor/golang.org/x/sys/windows/empty.s +deleted file mode 100644 +index ba64caca5d35..000000000000 +--- a/vendor/golang.org/x/sys/windows/empty.s ++++ /dev/null +@@ -1,8 +0,0 @@ +-// Copyright 2019 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 !go1.12 +- +-// This file is here to allow bodyless functions with go:linkname for Go 1.11 +-// and earlier (see https://golang.org/issue/23311). +diff --git a/vendor/golang.org/x/sys/windows/security_windows.go b/vendor/golang.org/x/sys/windows/security_windows.go +index 26be94a8a7b6..6f7d2ac70a93 100644 +--- a/vendor/golang.org/x/sys/windows/security_windows.go ++++ b/vendor/golang.org/x/sys/windows/security_windows.go +@@ -68,6 +68,7 @@ type UserInfo10 struct { + //sys NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) = netapi32.NetUserGetInfo + //sys NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) = netapi32.NetGetJoinInformation + //sys NetApiBufferFree(buf *byte) (neterr error) = netapi32.NetApiBufferFree ++//sys NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) = netapi32.NetUserEnum + + const ( + // do not reorder +diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go +index 6395a031d45d..6525c62f3c2f 100644 +--- a/vendor/golang.org/x/sys/windows/syscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/syscall_windows.go +@@ -165,6 +165,7 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW + //sys CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) [failretval==InvalidHandle] = CreateNamedPipeW + //sys ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) ++//sys DisconnectNamedPipe(pipe Handle) (err error) + //sys GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) + //sys GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW + //sys SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) = SetNamedPipeHandleState +@@ -348,8 +349,19 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys SetProcessPriorityBoost(process Handle, disable bool) (err error) = kernel32.SetProcessPriorityBoost + //sys GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintptr, lpMaximumWorkingSetSize *uintptr, flags *uint32) + //sys SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error) ++//sys ClearCommBreak(handle Handle) (err error) ++//sys ClearCommError(handle Handle, lpErrors *uint32, lpStat *ComStat) (err error) ++//sys EscapeCommFunction(handle Handle, dwFunc uint32) (err error) ++//sys GetCommState(handle Handle, lpDCB *DCB) (err error) ++//sys GetCommModemStatus(handle Handle, lpModemStat *uint32) (err error) + //sys GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) ++//sys PurgeComm(handle Handle, dwFlags uint32) (err error) ++//sys SetCommBreak(handle Handle) (err error) ++//sys SetCommMask(handle Handle, dwEvtMask uint32) (err error) ++//sys SetCommState(handle Handle, lpDCB *DCB) (err error) + //sys SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) ++//sys SetupComm(handle Handle, dwInQueue uint32, dwOutQueue uint32) (err error) ++//sys WaitCommEvent(handle Handle, lpEvtMask *uint32, lpOverlapped *Overlapped) (err error) + //sys GetActiveProcessorCount(groupNumber uint16) (ret uint32) + //sys GetMaximumProcessorCount(groupNumber uint16) (ret uint32) + //sys EnumWindows(enumFunc uintptr, param unsafe.Pointer) (err error) = user32.EnumWindows +@@ -1834,3 +1846,73 @@ func ResizePseudoConsole(pconsole Handle, size Coord) error { + // accept arguments that can be casted to uintptr, and Coord can't. + return resizePseudoConsole(pconsole, *((*uint32)(unsafe.Pointer(&size)))) + } ++ ++// DCB constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-dcb. ++const ( ++ CBR_110 = 110 ++ CBR_300 = 300 ++ CBR_600 = 600 ++ CBR_1200 = 1200 ++ CBR_2400 = 2400 ++ CBR_4800 = 4800 ++ CBR_9600 = 9600 ++ CBR_14400 = 14400 ++ CBR_19200 = 19200 ++ CBR_38400 = 38400 ++ CBR_57600 = 57600 ++ CBR_115200 = 115200 ++ CBR_128000 = 128000 ++ CBR_256000 = 256000 ++ ++ DTR_CONTROL_DISABLE = 0x00000000 ++ DTR_CONTROL_ENABLE = 0x00000010 ++ DTR_CONTROL_HANDSHAKE = 0x00000020 ++ ++ RTS_CONTROL_DISABLE = 0x00000000 ++ RTS_CONTROL_ENABLE = 0x00001000 ++ RTS_CONTROL_HANDSHAKE = 0x00002000 ++ RTS_CONTROL_TOGGLE = 0x00003000 ++ ++ NOPARITY = 0 ++ ODDPARITY = 1 ++ EVENPARITY = 2 ++ MARKPARITY = 3 ++ SPACEPARITY = 4 ++ ++ ONESTOPBIT = 0 ++ ONE5STOPBITS = 1 ++ TWOSTOPBITS = 2 ++) ++ ++// EscapeCommFunction constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-escapecommfunction. ++const ( ++ SETXOFF = 1 ++ SETXON = 2 ++ SETRTS = 3 ++ CLRRTS = 4 ++ SETDTR = 5 ++ CLRDTR = 6 ++ SETBREAK = 8 ++ CLRBREAK = 9 ++) ++ ++// PurgeComm constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-purgecomm. ++const ( ++ PURGE_TXABORT = 0x0001 ++ PURGE_RXABORT = 0x0002 ++ PURGE_TXCLEAR = 0x0004 ++ PURGE_RXCLEAR = 0x0008 ++) ++ ++// SetCommMask constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-setcommmask. ++const ( ++ EV_RXCHAR = 0x0001 ++ EV_RXFLAG = 0x0002 ++ EV_TXEMPTY = 0x0004 ++ EV_CTS = 0x0008 ++ EV_DSR = 0x0010 ++ EV_RLSD = 0x0020 ++ EV_BREAK = 0x0040 ++ EV_ERR = 0x0080 ++ EV_RING = 0x0100 ++) +diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go +index 359780f6ace5..d8cb71db0a61 100644 +--- a/vendor/golang.org/x/sys/windows/types_windows.go ++++ b/vendor/golang.org/x/sys/windows/types_windows.go +@@ -3380,3 +3380,27 @@ type BLOB struct { + Size uint32 + BlobData *byte + } ++ ++type ComStat struct { ++ Flags uint32 ++ CBInQue uint32 ++ CBOutQue uint32 ++} ++ ++type DCB struct { ++ DCBlength uint32 ++ BaudRate uint32 ++ Flags uint32 ++ wReserved uint16 ++ XonLim uint16 ++ XoffLim uint16 ++ ByteSize uint8 ++ Parity uint8 ++ StopBits uint8 ++ XonChar byte ++ XoffChar byte ++ ErrorChar byte ++ EofChar byte ++ EvtChar byte ++ wReserved1 uint16 ++} +diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +index e8791c82c30f..9f73df75b5fe 100644 +--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +@@ -188,6 +188,8 @@ var ( + procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") + procCancelIo = modkernel32.NewProc("CancelIo") + procCancelIoEx = modkernel32.NewProc("CancelIoEx") ++ procClearCommBreak = modkernel32.NewProc("ClearCommBreak") ++ procClearCommError = modkernel32.NewProc("ClearCommError") + procCloseHandle = modkernel32.NewProc("CloseHandle") + procClosePseudoConsole = modkernel32.NewProc("ClosePseudoConsole") + procConnectNamedPipe = modkernel32.NewProc("ConnectNamedPipe") +@@ -212,7 +214,9 @@ var ( + procDeleteProcThreadAttributeList = modkernel32.NewProc("DeleteProcThreadAttributeList") + procDeleteVolumeMountPointW = modkernel32.NewProc("DeleteVolumeMountPointW") + procDeviceIoControl = modkernel32.NewProc("DeviceIoControl") ++ procDisconnectNamedPipe = modkernel32.NewProc("DisconnectNamedPipe") + procDuplicateHandle = modkernel32.NewProc("DuplicateHandle") ++ procEscapeCommFunction = modkernel32.NewProc("EscapeCommFunction") + procExitProcess = modkernel32.NewProc("ExitProcess") + procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW") + procFindClose = modkernel32.NewProc("FindClose") +@@ -236,6 +240,8 @@ var ( + procGenerateConsoleCtrlEvent = modkernel32.NewProc("GenerateConsoleCtrlEvent") + procGetACP = modkernel32.NewProc("GetACP") + procGetActiveProcessorCount = modkernel32.NewProc("GetActiveProcessorCount") ++ procGetCommModemStatus = modkernel32.NewProc("GetCommModemStatus") ++ procGetCommState = modkernel32.NewProc("GetCommState") + procGetCommTimeouts = modkernel32.NewProc("GetCommTimeouts") + procGetCommandLineW = modkernel32.NewProc("GetCommandLineW") + procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW") +@@ -322,6 +328,7 @@ var ( + procProcess32NextW = modkernel32.NewProc("Process32NextW") + procProcessIdToSessionId = modkernel32.NewProc("ProcessIdToSessionId") + procPulseEvent = modkernel32.NewProc("PulseEvent") ++ procPurgeComm = modkernel32.NewProc("PurgeComm") + procQueryDosDeviceW = modkernel32.NewProc("QueryDosDeviceW") + procQueryFullProcessImageNameW = modkernel32.NewProc("QueryFullProcessImageNameW") + procQueryInformationJobObject = modkernel32.NewProc("QueryInformationJobObject") +@@ -335,6 +342,9 @@ var ( + procResetEvent = modkernel32.NewProc("ResetEvent") + procResizePseudoConsole = modkernel32.NewProc("ResizePseudoConsole") + procResumeThread = modkernel32.NewProc("ResumeThread") ++ procSetCommBreak = modkernel32.NewProc("SetCommBreak") ++ procSetCommMask = modkernel32.NewProc("SetCommMask") ++ procSetCommState = modkernel32.NewProc("SetCommState") + procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts") + procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition") + procSetConsoleMode = modkernel32.NewProc("SetConsoleMode") +@@ -342,7 +352,6 @@ var ( + procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories") + procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW") + procSetEndOfFile = modkernel32.NewProc("SetEndOfFile") +- procSetFileValidData = modkernel32.NewProc("SetFileValidData") + procSetEnvironmentVariableW = modkernel32.NewProc("SetEnvironmentVariableW") + procSetErrorMode = modkernel32.NewProc("SetErrorMode") + procSetEvent = modkernel32.NewProc("SetEvent") +@@ -351,6 +360,7 @@ var ( + procSetFileInformationByHandle = modkernel32.NewProc("SetFileInformationByHandle") + procSetFilePointer = modkernel32.NewProc("SetFilePointer") + procSetFileTime = modkernel32.NewProc("SetFileTime") ++ procSetFileValidData = modkernel32.NewProc("SetFileValidData") + procSetHandleInformation = modkernel32.NewProc("SetHandleInformation") + procSetInformationJobObject = modkernel32.NewProc("SetInformationJobObject") + procSetNamedPipeHandleState = modkernel32.NewProc("SetNamedPipeHandleState") +@@ -361,6 +371,7 @@ var ( + procSetStdHandle = modkernel32.NewProc("SetStdHandle") + procSetVolumeLabelW = modkernel32.NewProc("SetVolumeLabelW") + procSetVolumeMountPointW = modkernel32.NewProc("SetVolumeMountPointW") ++ procSetupComm = modkernel32.NewProc("SetupComm") + procSizeofResource = modkernel32.NewProc("SizeofResource") + procSleepEx = modkernel32.NewProc("SleepEx") + procTerminateJobObject = modkernel32.NewProc("TerminateJobObject") +@@ -379,6 +390,7 @@ var ( + procVirtualQueryEx = modkernel32.NewProc("VirtualQueryEx") + procVirtualUnlock = modkernel32.NewProc("VirtualUnlock") + procWTSGetActiveConsoleSessionId = modkernel32.NewProc("WTSGetActiveConsoleSessionId") ++ procWaitCommEvent = modkernel32.NewProc("WaitCommEvent") + procWaitForMultipleObjects = modkernel32.NewProc("WaitForMultipleObjects") + procWaitForSingleObject = modkernel32.NewProc("WaitForSingleObject") + procWriteConsoleW = modkernel32.NewProc("WriteConsoleW") +@@ -389,6 +401,7 @@ var ( + procTransmitFile = modmswsock.NewProc("TransmitFile") + procNetApiBufferFree = modnetapi32.NewProc("NetApiBufferFree") + procNetGetJoinInformation = modnetapi32.NewProc("NetGetJoinInformation") ++ procNetUserEnum = modnetapi32.NewProc("NetUserEnum") + procNetUserGetInfo = modnetapi32.NewProc("NetUserGetInfo") + procNtCreateFile = modntdll.NewProc("NtCreateFile") + procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile") +@@ -1641,6 +1654,22 @@ func CancelIoEx(s Handle, o *Overlapped) (err error) { + return + } + ++func ClearCommBreak(handle Handle) (err error) { ++ r1, _, e1 := syscall.Syscall(procClearCommBreak.Addr(), 1, uintptr(handle), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func ClearCommError(handle Handle, lpErrors *uint32, lpStat *ComStat) (err error) { ++ r1, _, e1 := syscall.Syscall(procClearCommError.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(lpErrors)), uintptr(unsafe.Pointer(lpStat))) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func CloseHandle(handle Handle) (err error) { + r1, _, e1 := syscall.Syscall(procCloseHandle.Addr(), 1, uintptr(handle), 0, 0) + if r1 == 0 { +@@ -1845,6 +1874,14 @@ func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBuff + return + } + ++func DisconnectNamedPipe(pipe Handle) (err error) { ++ r1, _, e1 := syscall.Syscall(procDisconnectNamedPipe.Addr(), 1, uintptr(pipe), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error) { + var _p0 uint32 + if bInheritHandle { +@@ -1857,6 +1894,14 @@ func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetP + return + } + ++func EscapeCommFunction(handle Handle, dwFunc uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procEscapeCommFunction.Addr(), 2, uintptr(handle), uintptr(dwFunc), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func ExitProcess(exitcode uint32) { + syscall.Syscall(procExitProcess.Addr(), 1, uintptr(exitcode), 0, 0) + return +@@ -2058,6 +2103,22 @@ func GetActiveProcessorCount(groupNumber uint16) (ret uint32) { + return + } + ++func GetCommModemStatus(handle Handle, lpModemStat *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetCommModemStatus.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(lpModemStat)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func GetCommState(handle Handle, lpDCB *DCB) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetCommState.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(lpDCB)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { + r1, _, e1 := syscall.Syscall(procGetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0) + if r1 == 0 { +@@ -2810,6 +2871,14 @@ func PulseEvent(event Handle) (err error) { + return + } + ++func PurgeComm(handle Handle, dwFlags uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procPurgeComm.Addr(), 2, uintptr(handle), uintptr(dwFlags), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) { + r0, _, e1 := syscall.Syscall(procQueryDosDeviceW.Addr(), 3, uintptr(unsafe.Pointer(deviceName)), uintptr(unsafe.Pointer(targetPath)), uintptr(max)) + n = uint32(r0) +@@ -2924,6 +2993,30 @@ func ResumeThread(thread Handle) (ret uint32, err error) { + return + } + ++func SetCommBreak(handle Handle) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetCommBreak.Addr(), 1, uintptr(handle), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func SetCommMask(handle Handle, dwEvtMask uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetCommMask.Addr(), 2, uintptr(handle), uintptr(dwEvtMask), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func SetCommState(handle Handle, lpDCB *DCB) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetCommState.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(lpDCB)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { + r1, _, e1 := syscall.Syscall(procSetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0) + if r1 == 0 { +@@ -2989,14 +3082,6 @@ func SetEndOfFile(handle Handle) (err error) { + return + } + +-func SetFileValidData(handle Handle, validDataLength int64) (err error) { +- r1, _, e1 := syscall.Syscall(procSetFileValidData.Addr(), 2, uintptr(handle), uintptr(validDataLength), 0) +- if r1 == 0 { +- err = errnoErr(e1) +- } +- return +-} +- + func SetEnvironmentVariable(name *uint16, value *uint16) (err error) { + r1, _, e1 := syscall.Syscall(procSetEnvironmentVariableW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), 0) + if r1 == 0 { +@@ -3060,6 +3145,14 @@ func SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetim + return + } + ++func SetFileValidData(handle Handle, validDataLength int64) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetFileValidData.Addr(), 2, uintptr(handle), uintptr(validDataLength), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error) { + r1, _, e1 := syscall.Syscall(procSetHandleInformation.Addr(), 3, uintptr(handle), uintptr(mask), uintptr(flags)) + if r1 == 0 { +@@ -3145,6 +3238,14 @@ func SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err erro + return + } + ++func SetupComm(handle Handle, dwInQueue uint32, dwOutQueue uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetupComm.Addr(), 3, uintptr(handle), uintptr(dwInQueue), uintptr(dwOutQueue)) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SizeofResource(module Handle, resInfo Handle) (size uint32, err error) { + r0, _, e1 := syscall.Syscall(procSizeofResource.Addr(), 2, uintptr(module), uintptr(resInfo), 0) + size = uint32(r0) +@@ -3291,6 +3392,14 @@ func WTSGetActiveConsoleSessionId() (sessionID uint32) { + return + } + ++func WaitCommEvent(handle Handle, lpEvtMask *uint32, lpOverlapped *Overlapped) (err error) { ++ r1, _, e1 := syscall.Syscall(procWaitCommEvent.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(lpEvtMask)), uintptr(unsafe.Pointer(lpOverlapped))) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func waitForMultipleObjects(count uint32, handles uintptr, waitAll bool, waitMilliseconds uint32) (event uint32, err error) { + var _p0 uint32 + if waitAll { +@@ -3378,6 +3487,14 @@ func NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (nete + return + } + ++func NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) { ++ r0, _, _ := syscall.Syscall9(procNetUserEnum.Addr(), 8, uintptr(unsafe.Pointer(serverName)), uintptr(level), uintptr(filter), uintptr(unsafe.Pointer(buf)), uintptr(prefMaxLen), uintptr(unsafe.Pointer(entriesRead)), uintptr(unsafe.Pointer(totalEntries)), uintptr(unsafe.Pointer(resumeHandle)), 0) ++ if r0 != 0 { ++ neterr = syscall.Errno(r0) ++ } ++ return ++} ++ + func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) { + r0, _, _ := syscall.Syscall6(procNetUserGetInfo.Addr(), 4, uintptr(unsafe.Pointer(serverName)), uintptr(unsafe.Pointer(userName)), uintptr(level), uintptr(unsafe.Pointer(buf)), 0, 0) + if r0 != 0 { +diff --git a/vendor/modules.txt b/vendor/modules.txt +index c7cfc95010df..8a02fed49171 100644 +--- a/vendor/modules.txt ++++ b/vendor/modules.txt +@@ -434,8 +434,8 @@ github.com/crc-org/vfkit/pkg/util + # github.com/cyberphone/json-canonicalization v0.0.0-20231011164504-785e29786b46 + ## explicit + github.com/cyberphone/json-canonicalization/go/src/webpki.org/jsoncanonicalizer +-# github.com/cyphar/filepath-securejoin v0.2.4 +-## explicit; go 1.13 ++# github.com/cyphar/filepath-securejoin v0.3.0 ++## explicit; go 1.20 + github.com/cyphar/filepath-securejoin + # github.com/davecgh/go-spew v1.1.1 + ## explicit +@@ -1009,8 +1009,8 @@ github.com/spf13/pflag + # github.com/stefanberger/go-pkcs11uri v0.0.0-20201008174630-78d3cae3a980 + ## explicit + github.com/stefanberger/go-pkcs11uri +-# github.com/stretchr/testify v1.8.4 +-## explicit; go 1.20 ++# github.com/stretchr/testify v1.9.0 ++## explicit; go 1.17 + github.com/stretchr/testify/assert + github.com/stretchr/testify/require + # github.com/sylabs/sif/v2 v2.15.0 +@@ -1192,7 +1192,7 @@ golang.org/x/oauth2/internal + ## explicit; go 1.18 + golang.org/x/sync/errgroup + golang.org/x/sync/semaphore +-# golang.org/x/sys v0.17.0 ++# golang.org/x/sys v0.21.0 + ## explicit; go 1.18 + golang.org/x/sys/cpu + golang.org/x/sys/execabs +-- +2.46.0 + diff --git a/podman.changes b/podman.changes index bc66e15..9a860db 100644 --- a/podman.changes +++ b/podman.changes @@ -1,3 +1,33 @@ +------------------------------------------------------------------- +Tue Oct 22 07:25:40 UTC 2024 - Danish Prakash + +- Add patch for CVE-2024-9676 (bsc#1231698): + * 0005-Use-securejoin.SecureJoin-when-forming-userns-paths.patch +- Rebase patches: + * 0001-Backport-fix-for-CVE-2024-6104.patch + * 0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch + * 0003-CVE-2024-9407-validate-bind-propagation-flag-setting.patch + * 0004-Properly-validate-cache-IDs-and-sources.patch + +------------------------------------------------------------------- +Tue Oct 15 17:03:17 UTC 2024 - Danish Prakash + +- Add patch for CVE-2024-9675 (bsc#1231499): + * 0004-Properly-validate-cache-IDs-and-sources.patch +- Add patch for CVE-2024-9407 (bsc#1231208): + * 0003-CVE-2024-9407-validate-bind-propagation-flag-setting.patch +- Rebase patches: + * 0001-Backport-fix-for-CVE-2024-6104.patch + * 0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch + +------------------------------------------------------------------- +Thu Oct 3 08:41:14 UTC 2024 - Danish Prakash + +- Add patch for CVE-2024-9341 (bsc#1231230): + * 0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch +- Rebase patch: + * 0001-Backport-fix-for-CVE-2024-6104.patch + ------------------------------------------------------------------- Thu Aug 29 08:49:02 UTC 2024 - danish.prakash@suse.com diff --git a/podman.spec b/podman.spec index 5581000..a3a5c8e 100644 --- a/podman.spec +++ b/podman.spec @@ -31,6 +31,10 @@ URL: https://%{project} Source0: %{name}-%{version}.tar.xz Source1: podman.conf Patch0: 0001-Backport-fix-for-CVE-2024-6104.patch +Patch1: 0002-pkg-subscriptions-use-securejoin-for-the-container-p.patch +Patch2: 0003-CVE-2024-9407-validate-bind-propagation-flag-setting.patch +Patch3: 0004-Properly-validate-cache-IDs-and-sources.patch +Patch4: 0005-Use-securejoin.SecureJoin-when-forming-userns-paths.patch BuildRequires: bash-completion BuildRequires: device-mapper-devel BuildRequires: fdupes