nuttx/binfmt/libelf/libelf_coredump.c

/****************************************************************************
 * binfmt/libelf/libelf_coredump.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>

#include <sys/stat.h>

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <debug.h>
#include <errno.h>

#include <nuttx/elf.h>
#include <nuttx/binfmt/elf.h>
#include <nuttx/binfmt/binfmt.h>
#include <nuttx/sched.h>
#include <sched/sched.h>

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define ELF_PAGESIZE    4096
#define ELF_BLOCKSIZE   1024

#define ARRAY_SIZE(x)   (sizeof(x) / sizeof((x)[0]))
#define ROUNDUP(x, y)   ((x + (y - 1)) / (y)) * (y)

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: elf_flush
 *
 * Description:
 *   Flush the out stream
 *
 ****************************************************************************/

static int elf_flush(FAR struct elf_dumpinfo_s *cinfo)
{
  return cinfo->stream->flush(cinfo->stream);
}

/****************************************************************************
 * Name: elf_emit
 *
 * Description:
 *   Send the dump data to binfmt_outstream_s
 *
 ****************************************************************************/

static int elf_emit(FAR struct elf_dumpinfo_s *cinfo,
                    FAR const void *buf, size_t len)
{
  FAR const uint8_t *ptr = buf;
  size_t total = len;
  int ret;

  while (total > 0)
    {
      ret = cinfo->stream->puts(cinfo->stream, ptr, total > ELF_BLOCKSIZE ?
                                ELF_BLOCKSIZE : total);
      if (ret < 0)
        {
          break;
        }

      total -= ret;
      ptr   += ret;
    }

  return ret < 0 ? ret : len - total;
}

/****************************************************************************
 * Name: elf_emit_align
 *
 * Description:
 *   Align the filled data according to the current offset
 *
 ****************************************************************************/

static int elf_emit_align(FAR struct elf_dumpinfo_s *cinfo)
{
  off_t align = ROUNDUP(cinfo->stream->nput,
                        ELF_PAGESIZE) - cinfo->stream->nput;
  unsigned char null[256];
  off_t total = align;
  off_t ret;

  memset(null, 0, sizeof(null));

  while (total > 0)
    {
      ret = elf_emit(cinfo, null, total > sizeof(null) ?
                                 sizeof(null) : total);
      if (ret <= 0)
        {
          break;
        }

      total -= ret;
    }

  return ret < 0 ? ret : align;
}

/****************************************************************************
 * Name: elf_emit_header
 *
 * Description:
 *   Fill the elf header
 *
 ****************************************************************************/

static int elf_emit_header(FAR struct elf_dumpinfo_s *cinfo,
                           int segs)
{
  Elf_Ehdr ehdr;

  memset(&ehdr, 0, sizeof(ehdr));
  memcpy(ehdr.e_ident, ELFMAG, EI_MAGIC_SIZE);

  ehdr.e_ident[EI_CLASS]   = ELF_CLASS;
  ehdr.e_ident[EI_DATA]    = ELF_DATA;
  ehdr.e_ident[EI_VERSION] = EV_CURRENT;
  ehdr.e_ident[EI_OSABI]   = ELF_OSABI;

  ehdr.e_type              = ET_CORE;
  ehdr.e_machine           = EM_ARCH;
  ehdr.e_version           = EV_CURRENT;
  ehdr.e_phoff             = sizeof(Elf_Ehdr);
  ehdr.e_flags             = EF_FLAG;
  ehdr.e_ehsize            = sizeof(Elf_Ehdr);
  ehdr.e_phentsize         = sizeof(Elf_Phdr);
  ehdr.e_phnum             = segs;

  return elf_emit(cinfo, &ehdr, sizeof(ehdr));
}

/****************************************************************************
 * Name: elf_get_note_size
 *
 * Description:
 *   Calculate the note segment size
 *
 ****************************************************************************/

static int elf_get_note_size(void)
{
  int count = 0;
  int total;
  int i;

  for (i = 0; i < g_npidhash; i++)
    {
      if (g_pidhash[i])
        {
          count++;
        }
    }

  total  = count * (sizeof(Elf_Nhdr) + ROUNDUP(CONFIG_TASK_NAME_SIZE, 8) +
                    sizeof(elf_prstatus_t));
  total += count * (sizeof(Elf_Nhdr) + ROUNDUP(CONFIG_TASK_NAME_SIZE, 8) +
                    sizeof(elf_prpsinfo_t));
  return total;
}

/****************************************************************************
 * Name: elf_emit_note_info
 *
 * Description:
 *   Fill the note segment information
 *
 ****************************************************************************/

static void elf_emit_note_info(FAR struct elf_dumpinfo_s *cinfo)
{
  char name[ROUNDUP(CONFIG_TASK_NAME_SIZE, 8)];
  FAR struct tcb_s *tcb;
  elf_prstatus_t status;
  elf_prpsinfo_t info;
  Elf_Nhdr nhdr;
  int i;
  int j;

  memset(&info,   0x0, sizeof(info));
  memset(&status, 0x0, sizeof(status));

  for (i = 0; i < g_npidhash; i++)
    {
      if (g_pidhash[i] == NULL)
        {
          continue;
        }

      tcb = g_pidhash[i];

      /* Fill Process info */

      nhdr.n_namesz = sizeof(name);
      nhdr.n_descsz = sizeof(info);
      nhdr.n_type   = NT_PRPSINFO;

      elf_emit(cinfo, &nhdr, sizeof(nhdr));

      strncpy(name, tcb->name, sizeof(name));
      elf_emit(cinfo, name, sizeof(name));

      info.pr_pid   = tcb->pid;
      strncpy(info.pr_fname, tcb->name, sizeof(info.pr_fname));
      elf_emit(cinfo, &info, sizeof(info));

      /* Fill Process status */

      nhdr.n_descsz = sizeof(status);
      nhdr.n_type   = NT_PRSTATUS;

      elf_emit(cinfo, &nhdr, sizeof(nhdr));
      elf_emit(cinfo, name, sizeof(name));

      status.pr_pid = tcb->pid;

      for (j = 0; j < ARRAY_SIZE(status.pr_regs); j++)
        {
          status.pr_regs[j] = *(uintptr_t *)((uint8_t *)tcb +
                                             g_tcbinfo.reg_offs[j]);
        }

      elf_emit(cinfo, &status, sizeof(status));
    }
}

/****************************************************************************
 * Name: elf_emit_program_header
 *
 * Description:
 *   Fill the program segment header
 *
 ****************************************************************************/

static void elf_emit_program_header(FAR struct elf_dumpinfo_s *cinfo,
                                    int segs)
{
  off_t offset = cinfo->stream->nput + (segs + 1) * sizeof(Elf_Phdr);
  Elf_Phdr phdr;
  int i;

  memset(&phdr, 0, sizeof(Elf_Phdr));

  phdr.p_type   = PT_NOTE;
  phdr.p_offset = offset;
  phdr.p_filesz = elf_get_note_size();
  offset       += phdr.p_filesz;

  elf_emit(cinfo, &phdr, sizeof(phdr));

  /* Write program headers for segments dump */

  for (i = 0; i < segs; i++)
    {
      phdr.p_type   = PT_LOAD;
      phdr.p_offset = ROUNDUP(offset, ELF_PAGESIZE);
      phdr.p_vaddr  = cinfo->regions[i].start;
      phdr.p_paddr  = cinfo->regions[i].start;
      phdr.p_filesz = cinfo->regions[i].end - cinfo->regions[i].start;
      phdr.p_memsz  = phdr.p_filesz;
      phdr.p_flags  = cinfo->regions[i].flags;
      phdr.p_align  = ELF_PAGESIZE;
      offset       += ROUNDUP(phdr.p_memsz, ELF_PAGESIZE);
      elf_emit(cinfo, &phdr, sizeof(phdr));
    }
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: elf_coredump
 *
 * Description:
 *   Generat the core dump stream as ELF structure.
 *
 * Input Parameters:
 *   dumpinfo - elf coredump informations
 *
 * Returned Value:
 *   Zero (OK) on success; a negated errno value on failure.
 *
 ****************************************************************************/

int elf_coredump(FAR struct elf_dumpinfo_s *cinfo)
{
  int segs = 0;
  int i;

  /* Check the memory region */

  if (cinfo->regions)
    {
      for (; cinfo->regions[segs].start <
             cinfo->regions[segs].end; segs++);
    }

  if (segs == 0)
    {
      return -EINVAL;
    }

  /* Fill notes section */

  elf_emit_header(cinfo, segs + 1);

  /* Fill all the program information about the process for the
   * notes.  This also sets up the file header.
   */

  elf_emit_program_header(cinfo, segs);

  /* Fill note information */

  elf_emit_note_info(cinfo);

  /* Align to page */

  elf_emit_align(cinfo);

  /* Start dump the memory */

  for (i = 0; i < segs; i++)
    {
      elf_emit(cinfo, (FAR void *)cinfo->regions[i].start,
               cinfo->regions[i].end -
               cinfo->regions[i].start);

      /* Align to page */

      elf_emit_align(cinfo);
    }

  /* Flush the dump */

  return elf_flush(cinfo);
}