/* Find Elf file and cache via Dwflst_Process_Tracker.

   Copyright (C) 2025, Red Hat, Inc.

   This file is part of elfutils.

   This file is free software; you can redistribute it and/or modify

   it under the terms of either

     * the GNU Lesser General Public License as published by the Free

       Software Foundation; either version 3 of the License, or (at

       your option) any later version

   or

     * the GNU General Public License as published by the Free

       Software Foundation; either version 2 of the License, or (at

       your option) any later version

   or both in parallel, as here.

   elfutils is distributed in the hope that it will be useful, but

   WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   General Public License for more details.

   You should have received copies of the GNU General Public License and

   the GNU Lesser General Public License along with this program.  If

   not, see <http://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <sys/stat.h>

#include "../libelf/libelfP.h"

/* XXX: Private header needed for Elf * ref_count field. */

/* TODO: Consider dup_elf() rather than direct ref_count access. */

#include "libdwfl_stacktraceP.h"

unsigned long int

__libdwfl_stacktrace_elftab_hash_st (const char *module_name,

             dev_t st_dev,

             ino_t st_ino)

{

  unsigned long int hval = elf_hash(module_name);

  hval ^= (unsigned long int)st_dev;

  hval ^= (unsigned long int)st_ino;

  return hval;

}

unsigned long int

__libdwfl_stacktrace_elftab_hash (const char *module_name,

          const char *module_path,

          int fd)

{

  struct stat sb;

  int rc = -1;

  if (fd >= 0)

    rc = fstat(fd, &sb);

  else if (module_path != NULL)

    rc = stat(module_path, &sb);

  if (rc < 0)

    return elf_hash(module_name);

  return __libdwfl_stacktrace_elftab_hash_st

    (module_name, sb.st_dev, sb.st_ino);

}

int

dwflst_tracker_find_cached_elf (Dwflst_Process_Tracker *tracker,

        const char *module_name,

        const char *module_path,

        char **file_name, Elf **elfp)

{

  dwflst_tracker_elf_info *ent = NULL;

  int rc = -1;

  struct stat sb;

  if (module_path == NULL)

    module_path = module_name;

  unsigned long int hval =

    __libdwfl_stacktrace_elftab_hash (module_name, module_path, -1/* no fd */);

  rwlock_rdlock(tracker->elftab_lock);

  ent = dwflst_tracker_elftab_find(&tracker->elftab, hval);

  rwlock_unlock(tracker->elftab_lock);

  /* Guard against collisions.

     TODO: Need proper chaining, dynamicsizehash_concurrent isn't really

     equipped for it. */

  if (ent != NULL)

    rc = fstat(ent->fd, &sb);

  if (rc < 0 || strcmp (module_name, ent->module_name) != 0

      || ent->dev != sb.st_dev || ent->ino != sb.st_ino)

    return -1;

  /* Verify that ent->fd has not been updated: */

  if (rc < 0 || ent->dev != sb.st_dev || ent->ino != sb.st_ino

      || ent->last_mtime != sb.st_mtime)

    return -1;

  if (ent->elf != NULL)

    ent->elf->ref_count++;

  *elfp = ent->elf;

  *file_name = strdup(ent->module_name);

  return ent->fd;

}

INTDEF(dwflst_tracker_find_cached_elf)

bool

dwflst_tracker_cache_elf (Dwflst_Process_Tracker *tracker,

        const char *module_name,

        const char *file_name __attribute__((unused)),

        Elf *elf, int fd)

{

  dwflst_tracker_elf_info *ent = NULL;

  int rc = -1;

  struct stat sb;

  if (fd >= 0)

    rc = fstat(fd, &sb);

  if (rc < 0)

    return false;

  unsigned long int hval =

    __libdwfl_stacktrace_elftab_hash_st (module_name, sb.st_dev, sb.st_ino);

  rwlock_wrlock(tracker->elftab_lock);

  ent = dwflst_tracker_elftab_find(&tracker->elftab, hval);

  /* Guard against collisions.

     TODO: Need proper chaining, dynamicsizehash_concurrent isn't really

     equipped for it. */

  if (ent != NULL && (strcmp (module_name, ent->module_name) != 0

          || ent->dev != sb.st_dev || ent->ino != sb.st_ino))

    {

      rwlock_unlock(tracker->elftab_lock);

      return false;

    }

  if (ent == NULL)

    {

      ent = calloc (1, sizeof (dwflst_tracker_elf_info));

      if (ent == NULL)

  {

    rwlock_unlock(tracker->elftab_lock);

    __libdwfl_seterrno (DWFL_E_NOMEM);

    return false;

  }

      ent->module_name = strdup(module_name);

      if (dwflst_tracker_elftab_insert(&tracker->elftab, hval, ent) != 0)

  {

    free(ent->module_name);

    free(ent);

    rwlock_unlock(tracker->elftab_lock);

    assert(false); /* Should not occur due to the wrlock on elftab. */

  }

    }

  else

    {

      /* TODO: The following assertions are still triggered on certain

   code paths that acquire fds or create Elf structs without

   checking the caching mechanism first.  This is not a serious

   problem, and can be fixed incrementally. */

      /* assert(ent->elf == NULL || ent->elf == elf); */ /* Guard against redundant/leaked Elf *. */

      /* assert(ent->fd == fd); */ /* Guard against redundant open. */

      /* For now, correct behaviour (from dwfl_module_getdwarf.c open_elf)

         is to replace the existing elf, keep module_name. */

      if (ent->elf != NULL && ent->elf != elf)

  elf_end(ent->elf);

    }

  if (elf != NULL && ent->elf != elf)

    elf->ref_count++;

  ent->elf = elf;

  ent->fd = fd;

  if (rc == 0)

    {

      ent->dev = sb.st_dev;

      ent->ino = sb.st_ino;

      ent->last_mtime = sb.st_mtime;

    }

  /* else create a cache entry with 0 values for dev/ino/mtime;

     since dev/ino are hashed, this will not conflict with entries

     for which fstat was successful */

  rwlock_unlock(tracker->elftab_lock);

  return true;

}

INTDEF(dwflst_tracker_cache_elf)

Dwflst_Process_Tracker *

dwflst_module_gettracker (Dwfl_Module *mod)

{

  if (mod == NULL)

    return NULL;

  if (mod->dwfl == NULL)

    return NULL;

  return mod->dwfl->tracker;

}

INTDEF(dwflst_module_gettracker)

int

dwflst_tracker_linux_proc_find_elf (Dwfl_Module *mod,

            void **userdata __attribute__ ((unused)),

            const char *module_name, Dwarf_Addr base,

            char **file_name, Elf **elfp)

{

  Dwflst_Process_Tracker *tracker = INTUSE(dwflst_module_gettracker) (mod);

  int fd;

  if (tracker != NULL)

    {

      fd = INTUSE(dwflst_tracker_find_cached_elf)

  (tracker, module_name, module_name, file_name, elfp);

      if (fd >= 0)

  return fd;

    }

  fd = INTUSE(dwfl_linux_proc_find_elf) (mod, userdata, module_name,

           base, file_name, elfp);

  if (tracker != NULL && fd >= 0 && *file_name != NULL)

    {

      INTUSE(dwflst_tracker_cache_elf)

  (tracker, module_name, *file_name, *elfp, fd);

    }

  return fd;

}