lib/crunchrun/singularity.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package crunchrun
   6
   7 import (
   8         "bytes"
   9         "context"
  10         "encoding/json"
  11         "errors"
  12         "fmt"
  13         "io/ioutil"
  14         "net"
  15         "os"
  16         "os/exec"
  17         "os/user"
  18         "path"
  19         "regexp"
  20         "sort"
  21         "strconv"
  22         "strings"
  23         "syscall"
  24         "time"
  25
  26         "git.arvados.org/arvados.git/sdk/go/arvados"
  27 )
  28
  29 type singularityExecutor struct {
  30         logf          func(string, ...interface{})
  31         sudo          bool // use sudo to run singularity (only used by tests)
  32         spec          containerSpec
  33         tmpdir        string
  34         child         *exec.Cmd
  35         imageFilename string // "sif" image
  36 }
  37
  38 func newSingularityExecutor(logf func(string, ...interface{})) (*singularityExecutor, error) {
  39         tmpdir, err := ioutil.TempDir("", "crunch-run-singularity-")
  40         if err != nil {
  41                 return nil, err
  42         }
  43         return &singularityExecutor{
  44                 logf:   logf,
  45                 tmpdir: tmpdir,
  46         }, nil
  47 }
  48
  49 func (e *singularityExecutor) Runtime() string {
  50         buf, err := exec.Command("singularity", "--version").CombinedOutput()
  51         if err != nil {
  52                 return "singularity (unknown version)"
  53         }
  54         return strings.TrimSuffix(string(buf), "\n")
  55 }
  56
  57 func (e *singularityExecutor) getOrCreateProject(ownerUuid string, name string, containerClient *arvados.Client) (*arvados.Group, error) {
  58         var gp arvados.GroupList
  59         err := containerClient.RequestAndDecode(&gp,
  60                 arvados.EndpointGroupList.Method,
  61                 arvados.EndpointGroupList.Path,
  62                 nil, arvados.ListOptions{Filters: []arvados.Filter{
  63                         arvados.Filter{"owner_uuid", "=", ownerUuid},
  64                         arvados.Filter{"name", "=", name},
  65                         arvados.Filter{"group_class", "=", "project"},
  66                 },
  67                         Limit: 1})
  68         if err != nil {
  69                 return nil, err
  70         }
  71         if len(gp.Items) == 1 {
  72                 return &gp.Items[0], nil
  73         }
  74
  75         var rgroup arvados.Group
  76         err = containerClient.RequestAndDecode(&rgroup,
  77                 arvados.EndpointGroupCreate.Method,
  78                 arvados.EndpointGroupCreate.Path,
  79                 nil, map[string]interface{}{
  80                         "group": map[string]string{
  81                                 "owner_uuid":  ownerUuid,
  82                                 "name":        name,
  83                                 "group_class": "project",
  84                         },
  85                 })
  86         if err != nil {
  87                 return nil, err
  88         }
  89         return &rgroup, nil
  90 }
  91
  92 func (e *singularityExecutor) getImageCacheProject(userUUID string, containerClient *arvados.Client) (*arvados.Group, error) {
  93         cacheProject, err := e.getOrCreateProject(userUUID, ".cache", containerClient)
  94         if err != nil {
  95                 return nil, fmt.Errorf("error getting '.cache' project: %v", err)
  96         }
  97         imageProject, err := e.getOrCreateProject(cacheProject.UUID, "auto-generated singularity images", containerClient)
  98         if err != nil {
  99                 return nil, fmt.Errorf("error getting 'auto-generated singularity images' project: %s", err)
 100         }
 101         return imageProject, nil
 102 }
 103
 104 func (e *singularityExecutor) imageCacheExp() time.Time {
 105         return time.Now().Add(e.imageCacheTTL()).UTC()
 106 }
 107
 108 func (e *singularityExecutor) imageCacheTTL() time.Duration {
 109         return 24 * 7 * 2 * time.Hour
 110 }
 111
 112 // getCacheCollection returns an existing collection with a cached
 113 // singularity image with the given name, or nil if none exists.
 114 //
 115 // Note that if there is no existing collection, this is not
 116 // considered an error -- all return values will be nil/empty.
 117 func (e *singularityExecutor) getCacheCollection(collectionName string, containerClient *arvados.Client, cacheProject *arvados.Group, arvMountPoint string) (collection *arvados.Collection, imageFile string, err error) {
 118         var cl arvados.CollectionList
 119         err = containerClient.RequestAndDecode(&cl,
 120                 arvados.EndpointCollectionList.Method,
 121                 arvados.EndpointCollectionList.Path,
 122                 nil, arvados.ListOptions{Filters: []arvados.Filter{
 123                         arvados.Filter{"owner_uuid", "=", cacheProject.UUID},
 124                         arvados.Filter{"name", "=", collectionName},
 125                 },
 126                         Limit: 1})
 127         if err != nil {
 128                 return nil, "", fmt.Errorf("error querying for collection %q in project %s: %w", collectionName, cacheProject.UUID, err)
 129         }
 130         if len(cl.Items) == 0 {
 131                 // Successfully discovered that there's no cached
 132                 // image collection.
 133                 return nil, "", nil
 134         }
 135         // Check that the collection actually contains an "image.sif"
 136         // file.  If not, we can't use it, and trying to create a new
 137         // cache collection will probably fail too, so the caller
 138         // should not bother trying.
 139         coll := cl.Items[0]
 140         sifFile := path.Join(arvMountPoint, "by_id", coll.PortableDataHash, "image.sif")
 141         _, err = os.Stat(sifFile)
 142         if err != nil {
 143                 return nil, "", fmt.Errorf("found collection %s (%s), but it did not contain an image file: %s", coll.UUID, coll.PortableDataHash, err)
 144         }
 145         if coll.TrashAt != nil && coll.TrashAt.Sub(time.Now()) < e.imageCacheTTL()*9/10 {
 146                 // If the remaining TTL is less than 90% of our target
 147                 // TTL, extend trash_at.  This avoids prematurely
 148                 // trashing and re-converting images that are being
 149                 // used regularly.
 150                 err = containerClient.RequestAndDecode(nil,
 151                         arvados.EndpointCollectionUpdate.Method,
 152                         "arvados/v1/collections/"+coll.UUID,
 153                         nil, map[string]interface{}{
 154                                 "collection": map[string]string{
 155                                         "trash_at": e.imageCacheExp().Format(time.RFC3339),
 156                                 },
 157                         })
 158                 if err != nil {
 159                         e.logf("could not update expiry time of cached image collection (proceeding anyway): %s", err)
 160                 }
 161         }
 162         return &coll, sifFile, nil
 163 }
 164
 165 func (e *singularityExecutor) createCacheCollection(collectionName string, containerClient *arvados.Client, cacheProject *arvados.Group) (*arvados.Collection, error) {
 166         var coll arvados.Collection
 167         err := containerClient.RequestAndDecode(&coll,
 168                 arvados.EndpointCollectionCreate.Method,
 169                 arvados.EndpointCollectionCreate.Path,
 170                 nil, map[string]interface{}{
 171                         "collection": map[string]string{
 172                                 "owner_uuid": cacheProject.UUID,
 173                                 "name":       collectionName,
 174                                 "trash_at":   e.imageCacheExp().Format(time.RFC3339),
 175                         },
 176                         "ensure_unique_name": true,
 177                 })
 178         if err != nil {
 179                 return nil, fmt.Errorf("error creating '%v' collection: %s", collectionName, err)
 180         }
 181         return &coll, nil
 182 }
 183
 184 func (e *singularityExecutor) convertDockerImage(srcPath, dstPath string) error {
 185         // Make sure the docker image is readable.
 186         if _, err := os.Stat(srcPath); err != nil {
 187                 return err
 188         }
 189
 190         e.logf("building singularity image")
 191         // "singularity build" does not accept a
 192         // docker-archive://... filename containing a ":" character,
 193         // as in "/path/to/sha256:abcd...1234.tar". Workaround: make a
 194         // symlink that doesn't have ":" chars.
 195         err := os.Symlink(srcPath, e.tmpdir+"/image.tar")
 196         if err != nil {
 197                 return err
 198         }
 199
 200         // Set up a cache and tmp dir for singularity build
 201         err = os.Mkdir(e.tmpdir+"/cache", 0700)
 202         if err != nil {
 203                 return err
 204         }
 205         defer os.RemoveAll(e.tmpdir + "/cache")
 206         err = os.Mkdir(e.tmpdir+"/tmp", 0700)
 207         if err != nil {
 208                 return err
 209         }
 210         defer os.RemoveAll(e.tmpdir + "/tmp")
 211
 212         build := exec.Command("singularity", "build", dstPath, "docker-archive://"+e.tmpdir+"/image.tar")
 213         build.Env = os.Environ()
 214         build.Env = append(build.Env, "SINGULARITY_CACHEDIR="+e.tmpdir+"/cache")
 215         build.Env = append(build.Env, "SINGULARITY_TMPDIR="+e.tmpdir+"/tmp")
 216         e.logf("%v", build.Args)
 217         out, err := build.CombinedOutput()
 218         // INFO:    Starting build...
 219         // Getting image source signatures
 220         // Copying blob ab15617702de done
 221         // Copying config 651e02b8a2 done
 222         // Writing manifest to image destination
 223         // Storing signatures
 224         // 2021/04/22 14:42:14  info unpack layer: sha256:21cbfd3a344c52b197b9fa36091e66d9cbe52232703ff78d44734f85abb7ccd3
 225         // INFO:    Creating SIF file...
 226         // INFO:    Build complete: arvados-jobs.latest.sif
 227         e.logf("%s", out)
 228         return err
 229 }
 230
 231 // LoadImage converts the given docker image to a singularity
 232 // image.
 233 //
 234 // If containerClient is not nil, LoadImage first tries to use an
 235 // existing image (in Home -> .cache -> auto-generated singularity
 236 // images) and, if none was found there and the image was converted on
 237 // the fly, tries to save the converted image to the cache so it can
 238 // be reused next time.
 239 //
 240 // If containerClient is nil or a cache project/collection cannot be
 241 // found or created, LoadImage converts the image on the fly and
 242 // writes it to the local filesystem instead.
 243 func (e *singularityExecutor) LoadImage(dockerImageID string, imageTarballPath string, container arvados.Container, arvMountPoint string, containerClient *arvados.Client) error {
 244         convertWithoutCache := func(err error) error {
 245                 if err != nil {
 246                         e.logf("cannot use singularity image cache: %s", err)
 247                 }
 248                 e.imageFilename = path.Join(e.tmpdir, "image.sif")
 249                 return e.convertDockerImage(imageTarballPath, e.imageFilename)
 250         }
 251
 252         if containerClient == nil {
 253                 return convertWithoutCache(nil)
 254         }
 255         cacheProject, err := e.getImageCacheProject(container.RuntimeUserUUID, containerClient)
 256         if err != nil {
 257                 return convertWithoutCache(err)
 258         }
 259         cacheCollectionName := fmt.Sprintf("singularity image for %s", dockerImageID)
 260         existingCollection, sifFile, err := e.getCacheCollection(cacheCollectionName, containerClient, cacheProject, arvMountPoint)
 261         if err != nil {
 262                 return convertWithoutCache(err)
 263         }
 264         if existingCollection != nil {
 265                 e.imageFilename = sifFile
 266                 return nil
 267         }
 268
 269         newCollection, err := e.createCacheCollection("converting "+cacheCollectionName, containerClient, cacheProject)
 270         if err != nil {
 271                 return convertWithoutCache(err)
 272         }
 273         dstDir := path.Join(arvMountPoint, "by_uuid", newCollection.UUID)
 274         dstFile := path.Join(dstDir, "image.sif")
 275         err = e.convertDockerImage(imageTarballPath, dstFile)
 276         if err != nil {
 277                 return err
 278         }
 279         buf, err := os.ReadFile(path.Join(dstDir, ".arvados#collection"))
 280         if err != nil {
 281                 return fmt.Errorf("could not sync image collection: %w", err)
 282         }
 283         var synced arvados.Collection
 284         err = json.Unmarshal(buf, &synced)
 285         if err != nil {
 286                 return fmt.Errorf("could not parse .arvados#collection: %w", err)
 287         }
 288         e.logf("saved converted image in %s with PDH %s", newCollection.UUID, synced.PortableDataHash)
 289         e.imageFilename = path.Join(arvMountPoint, "by_id", synced.PortableDataHash, "image.sif")
 290
 291         if errRename := containerClient.RequestAndDecode(nil,
 292                 arvados.EndpointCollectionUpdate.Method,
 293                 "arvados/v1/collections/"+newCollection.UUID,
 294                 nil, map[string]interface{}{
 295                         "collection": map[string]string{
 296                                 "name": cacheCollectionName,
 297                         },
 298                 }); errRename != nil {
 299                 // Error is probably a name collision caused by
 300                 // another crunch-run process is converting the same
 301                 // image concurrently.  In that case, we prefer to use
 302                 // the one that won the race -- the resulting images
 303                 // should be equivalent, but if they do differ at all,
 304                 // it's better if all containers use the same
 305                 // conversion.
 306                 if existingCollection, sifFile, err := e.getCacheCollection(cacheCollectionName, containerClient, cacheProject, arvMountPoint); err == nil {
 307                         e.logf("lost race -- abandoning our conversion in %s (%s) and using image from %s (%s) instead", newCollection.UUID, synced.PortableDataHash, existingCollection.UUID, existingCollection.PortableDataHash)
 308                         e.imageFilename = sifFile
 309                 } else {
 310                         e.logf("using newly converted image anyway, despite error renaming collection: %v", errRename)
 311                 }
 312         }
 313         return nil
 314 }
 315
 316 func (e *singularityExecutor) Create(spec containerSpec) error {
 317         e.spec = spec
 318         return nil
 319 }
 320
 321 func (e *singularityExecutor) execCmd(path string) *exec.Cmd {
 322         args := []string{path, "exec", "--containall", "--cleanenv", "--pwd=" + e.spec.WorkingDir}
 323         if !e.spec.EnableNetwork {
 324                 args = append(args, "--net", "--network=none")
 325         } else if u, err := user.Current(); err == nil && u.Uid == "0" || e.sudo {
 326                 // Specifying --network=bridge fails unless
 327                 // singularity is running as root.
 328                 //
 329                 // Note this used to be possible with --fakeroot, or
 330                 // configuring singularity like so:
 331                 //
 332                 // singularity config global --set 'allow net networks' bridge
 333                 // singularity config global --set 'allow net groups' mygroup
 334                 //
 335                 // However, these options no longer work (as of debian
 336                 // bookworm) because iptables now refuses to run in a
 337                 // setuid environment.
 338                 args = append(args, "--net", "--network=bridge")
 339         } else {
 340                 // If we don't pass a --net argument at all, the
 341                 // container will be in the same network namespace as
 342                 // the host.
 343                 //
 344                 // Note this allows the container to listen on the
 345                 // host's external ports.
 346         }
 347         if e.spec.CUDADeviceCount != 0 {
 348                 args = append(args, "--nv")
 349         }
 350
 351         // If we ask for resource limits that aren't supported,
 352         // singularity will not run the container at all. So we probe
 353         // for support first, and only apply the limits that appear to
 354         // be supported.
 355         //
 356         // Default debian configuration lets non-root users set memory
 357         // limits but not CPU limits, so we enable/disable those
 358         // limits independently.
 359         //
 360         // https://rootlesscontaine.rs/getting-started/common/cgroup2/
 361         checkCgroupSupport(e.logf)
 362         if e.spec.VCPUs > 0 {
 363                 if cgroupSupport["cpu"] {
 364                         args = append(args, "--cpus", fmt.Sprintf("%d", e.spec.VCPUs))
 365                 } else {
 366                         e.logf("cpu limits are not supported by current systemd/cgroup configuration, not setting --cpu %d", e.spec.VCPUs)
 367                 }
 368         }
 369         if e.spec.RAM > 0 {
 370                 if cgroupSupport["memory"] {
 371                         args = append(args, "--memory", fmt.Sprintf("%d", e.spec.RAM))
 372                 } else {
 373                         e.logf("memory limits are not supported by current systemd/cgroup configuration, not setting --memory %d", e.spec.RAM)
 374                 }
 375         }
 376
 377         readonlyflag := map[bool]string{
 378                 false: "rw",
 379                 true:  "ro",
 380         }
 381         var binds []string
 382         for path, _ := range e.spec.BindMounts {
 383                 binds = append(binds, path)
 384         }
 385         sort.Strings(binds)
 386         for _, path := range binds {
 387                 mount := e.spec.BindMounts[path]
 388                 if path == e.spec.Env["HOME"] {
 389                         // Singularity treats $HOME as special case
 390                         args = append(args, "--home", mount.HostPath+":"+path)
 391                 } else {
 392                         args = append(args, "--bind", mount.HostPath+":"+path+":"+readonlyflag[mount.ReadOnly])
 393                 }
 394         }
 395
 396         // This is for singularity 3.5.2. There are some behaviors
 397         // that will change in singularity 3.6, please see:
 398         // https://sylabs.io/guides/3.7/user-guide/environment_and_metadata.html
 399         // https://sylabs.io/guides/3.5/user-guide/environment_and_metadata.html
 400         env := make([]string, 0, len(e.spec.Env))
 401         for k, v := range e.spec.Env {
 402                 if k == "HOME" {
 403                         // Singularity treats $HOME as special case,
 404                         // this is handled with --home above
 405                         continue
 406                 }
 407                 env = append(env, "SINGULARITYENV_"+k+"="+v)
 408         }
 409
 410         // Singularity always makes all nvidia devices visible to the
 411         // container.  If a resource manager such as slurm or LSF told
 412         // us to select specific devices we need to propagate that.
 413         if cudaVisibleDevices := os.Getenv("CUDA_VISIBLE_DEVICES"); cudaVisibleDevices != "" {
 414                 // If a resource manager such as slurm or LSF told
 415                 // us to select specific devices we need to propagate that.
 416                 env = append(env, "SINGULARITYENV_CUDA_VISIBLE_DEVICES="+cudaVisibleDevices)
 417         }
 418         // Singularity's default behavior is to evaluate each
 419         // SINGULARITYENV_* env var with a shell as a double-quoted
 420         // string and pass the result to the contained
 421         // process. Singularity 3.10+ has an option to pass env vars
 422         // through literally without evaluating, which is what we
 423         // want. See https://github.com/sylabs/singularity/pull/704
 424         // and https://dev.arvados.org/issues/19081
 425         env = append(env, "SINGULARITY_NO_EVAL=1")
 426
 427         // If we don't propagate XDG_RUNTIME_DIR and
 428         // DBUS_SESSION_BUS_ADDRESS, singularity resource limits fail
 429         // with "FATAL: container creation failed: while applying
 430         // cgroups config: system configuration does not support
 431         // cgroup management" or "FATAL: container creation failed:
 432         // while applying cgroups config: rootless cgroups require a
 433         // D-Bus session - check that XDG_RUNTIME_DIR and
 434         // DBUS_SESSION_BUS_ADDRESS are set".
 435         env = append(env, "XDG_RUNTIME_DIR="+os.Getenv("XDG_RUNTIME_DIR"))
 436         env = append(env, "DBUS_SESSION_BUS_ADDRESS="+os.Getenv("DBUS_SESSION_BUS_ADDRESS"))
 437
 438         args = append(args, e.imageFilename)
 439         args = append(args, e.spec.Command...)
 440
 441         return &exec.Cmd{
 442                 Path:   path,
 443                 Args:   args,
 444                 Env:    env,
 445                 Stdin:  e.spec.Stdin,
 446                 Stdout: e.spec.Stdout,
 447                 Stderr: e.spec.Stderr,
 448         }
 449 }
 450
 451 func (e *singularityExecutor) Start() error {
 452         path, err := exec.LookPath("singularity")
 453         if err != nil {
 454                 return err
 455         }
 456         child := e.execCmd(path)
 457         if e.sudo {
 458                 child.Args = append([]string{child.Path}, child.Args...)
 459                 child.Path, err = exec.LookPath("sudo")
 460                 if err != nil {
 461                         return err
 462                 }
 463         }
 464         err = child.Start()
 465         if err != nil {
 466                 return err
 467         }
 468         e.child = child
 469         return nil
 470 }
 471
 472 func (e *singularityExecutor) Pid() int {
 473         childproc, err := e.containedProcess()
 474         if err != nil {
 475                 return 0
 476         }
 477         return childproc
 478 }
 479
 480 func (e *singularityExecutor) Stop() error {
 481         if e.child == nil || e.child.Process == nil {
 482                 // no process started, or Wait already called
 483                 return nil
 484         }
 485         if err := e.child.Process.Signal(syscall.Signal(0)); err != nil {
 486                 // process already exited
 487                 return nil
 488         }
 489         return e.child.Process.Signal(syscall.SIGKILL)
 490 }
 491
 492 func (e *singularityExecutor) Wait(context.Context) (int, error) {
 493         err := e.child.Wait()
 494         if err, ok := err.(*exec.ExitError); ok {
 495                 return err.ProcessState.ExitCode(), nil
 496         }
 497         if err != nil {
 498                 return 0, err
 499         }
 500         return e.child.ProcessState.ExitCode(), nil
 501 }
 502
 503 func (e *singularityExecutor) Close() {
 504         err := os.RemoveAll(e.tmpdir)
 505         if err != nil {
 506                 e.logf("error removing temp dir: %s", err)
 507         }
 508 }
 509
 510 func (e *singularityExecutor) InjectCommand(ctx context.Context, detachKeys, username string, usingTTY bool, injectcmd []string) (*exec.Cmd, error) {
 511         target, err := e.containedProcess()
 512         if err != nil {
 513                 return nil, err
 514         }
 515         return exec.CommandContext(ctx, "nsenter", append([]string{fmt.Sprintf("--target=%d", target), "--all"}, injectcmd...)...), nil
 516 }
 517
 518 var (
 519         errContainerHasNoIPAddress = errors.New("container has no IP address distinct from host")
 520 )
 521
 522 func (e *singularityExecutor) IPAddress() (string, error) {
 523         target, err := e.containedProcess()
 524         if err != nil {
 525                 return "", err
 526         }
 527         targetIPs, err := processIPs(target)
 528         if err != nil {
 529                 return "", err
 530         }
 531         selfIPs, err := processIPs(os.Getpid())
 532         if err != nil {
 533                 return "", err
 534         }
 535         for ip := range targetIPs {
 536                 if !selfIPs[ip] {
 537                         return ip, nil
 538                 }
 539         }
 540         return "", errContainerHasNoIPAddress
 541 }
 542
 543 func processIPs(pid int) (map[string]bool, error) {
 544         fibtrie, err := os.ReadFile(fmt.Sprintf("/proc/%d/net/fib_trie", pid))
 545         if err != nil {
 546                 return nil, err
 547         }
 548
 549         addrs := map[string]bool{}
 550         // When we see a pair of lines like this:
 551         //
 552         //              |-- 10.1.2.3
 553         //                 /32 host LOCAL
 554         //
 555         // ...we set addrs["10.1.2.3"] = true
 556         lines := bytes.Split(fibtrie, []byte{'\n'})
 557         for linenumber, line := range lines {
 558                 if !bytes.HasSuffix(line, []byte("/32 host LOCAL")) {
 559                         continue
 560                 }
 561                 if linenumber < 1 {
 562                         continue
 563                 }
 564                 i := bytes.LastIndexByte(lines[linenumber-1], ' ')
 565                 if i < 0 || i >= len(line)-7 {
 566                         continue
 567                 }
 568                 addr := string(lines[linenumber-1][i+1:])
 569                 if net.ParseIP(addr).To4() != nil {
 570                         addrs[addr] = true
 571                 }
 572         }
 573         return addrs, nil
 574 }
 575
 576 var (
 577         errContainerNotStarted = errors.New("container has not started yet")
 578         errCannotFindChild     = errors.New("failed to find any process inside the container")
 579         reProcStatusPPid       = regexp.MustCompile(`\nPPid:\t(\d+)\n`)
 580 )
 581
 582 // Return the PID of a process that is inside the container (not
 583 // necessarily the topmost/pid=1 process in the container).
 584 func (e *singularityExecutor) containedProcess() (int, error) {
 585         if e.child == nil || e.child.Process == nil {
 586                 return 0, errContainerNotStarted
 587         }
 588         cmd := exec.Command("lsns")
 589         if e.sudo {
 590                 cmd = exec.Command("sudo", "lsns")
 591         }
 592         lsns, err := cmd.CombinedOutput()
 593         if err != nil {
 594                 return 0, fmt.Errorf("lsns: %w", err)
 595         }
 596         for _, line := range bytes.Split(lsns, []byte{'\n'}) {
 597                 fields := bytes.Fields(line)
 598                 if len(fields) < 4 {
 599                         continue
 600                 }
 601                 if !bytes.Equal(fields[1], []byte("pid")) {
 602                         continue
 603                 }
 604                 pid, err := strconv.ParseInt(string(fields[3]), 10, 64)
 605                 if err != nil {
 606                         return 0, fmt.Errorf("error parsing PID field in lsns output: %q", fields[3])
 607                 }
 608                 for parent := pid; ; {
 609                         procstatus, err := os.ReadFile(fmt.Sprintf("/proc/%d/status", parent))
 610                         if err != nil {
 611                                 break
 612                         }
 613                         m := reProcStatusPPid.FindSubmatch(procstatus)
 614                         if m == nil {
 615                                 break
 616                         }
 617                         parent, err = strconv.ParseInt(string(m[1]), 10, 64)
 618                         if err != nil {
 619                                 break
 620                         }
 621                         if int(parent) == e.child.Process.Pid {
 622                                 return int(pid), nil
 623                         }
 624                 }
 625         }
 626         return 0, errCannotFindChild
 627 }