Changeset a33f0a6 in mainline for uspace/app/taskdump/elf_core.c

Timestamp:

2011-08-03T17:34:57Z (14 years ago)

Author:

Oleg Romanenko <romanenko.oleg@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

1940326

Parents:

52a79081 (diff), 3fab770 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from mainline

File:

• uspace/app/taskdump/elf_core.c (modified) (15 diffs)

uspace/app/taskdump/elf_core.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -38 +38 @@
  * Looking at core files produced by Linux, these don't have section headers,
  * only program headers, although objdump shows them as having sections.
- * Basically at the beginning there should be a note segment (which we
- * do not write) and one loadable segment per memory area (which we do write).
- *
- * The note segment probably contains register state, etc. -- we don't
- * deal with these yet. Nevertheless you can use these core files with
- * objdump or gdb.
- */
-
+ * Basically at the beginning there should be a note segment followed
+ * by one loadable segment per memory area.
+ *
+ * The note segment contains a series of records with register state,
+ * process info etc. We only write one record NT_PRSTATUS which contains
+ * process/register state (anything which is not register state we fill
+ * with zeroes).
+ */
+
+#include <align.h>
+#include <elf/elf.h>
+#include <elf/elf_linux.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -58 +62 @@
 #include <udebug.h>
 #include <macros.h>
-
-#include <elf.h>
-#include "include/elf_core.h"
-
-static off64_t align_foff_up(off64_t foff, uintptr_t vaddr, size_t page_size);
-static int write_all(int fd, void *data, size_t len);
-static int write_mem_area(int fd, as_area_info_t *area, int phoneid);
+#include <libarch/istate.h>
+
+#include "elf_core.h"
+
+static off64_t align_foff_up(off64_t, uintptr_t, size_t);
+static int align_pos(int, size_t);
+static int write_mem_area(int, as_area_info_t *, async_sess_t *);
 
 #define BUFFER_SIZE 0x1000
@@ -71 +75 @@
 /** Save ELF core file.
  *
- * @param file_name     Name of file to save to.
- * @param ainfo         Array of @a n memory area info structures.
- * @param n             Number of memory areas.
- * @param phoneid       Debugging phone.
- *
- * @return              EOK on sucess, ENOENT if file cannot be created,
- *                      ENOMEM on out of memory, EIO on write error.
- */
-int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid)
+ * @param file_name Name of file to save to.
+ * @param ainfo     Array of @a n memory area info structures.
+ * @param n         Number of memory areas.
+ * @param sess      Debugging session.
+ *
+ * @return EOK on sucess.
+ * @return ENOENT if file cannot be created.
+ * @return ENOMEM on out of memory.
+ * @return EIO on write error.
+ *
+ */
+int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n,
+    async_sess_t *sess, istate_t *istate)
 {
         elf_header_t elf_hdr;
@@ -86 +94 @@
         elf_word flags;
         elf_segment_header_t *p_hdr;
+        elf_prstatus_t pr_status;
+        elf_note_t note;
+        size_t word_size;
 
         int fd;
-        int rc;
+        ssize_t rc;
         unsigned int i;
 
-        n_ph = n;
-
-        p_hdr = malloc(sizeof(elf_segment_header_t) * n);
+#ifdef __32_BITS__
+        word_size = 4;
+#endif
+#ifdef __64_BITS__
+        /*
+         * This should be 8 per the 64-bit ELF spec, but the Linux kernel
+         * screws up and uses 4 anyway (and screws up elf_note_t as well)
+         * and we are trying to be compatible with Linux GDB target. Sigh.
+         */
+        word_size = 4;
+#endif
+        memset(&pr_status, 0, sizeof(pr_status));
+        istate_to_elf_regs(istate, &pr_status.regs);
+
+        n_ph = n + 1;
+
+        p_hdr = malloc(sizeof(elf_segment_header_t) * n_ph);
         if (p_hdr == NULL) {
                 printf("Failed allocating memory.\n");
@@ -111 +136 @@
          *      ELF header
          *      program headers
+         *      note segment
          * repeat:
          *      (pad for alignment)
-         *      segment data
+         *      core segment
          * end repeat
          */
@@ -143 +169 @@
         foff = elf_hdr.e_phoff + n_ph * sizeof(elf_segment_header_t);
 
-        for (i = 1; i <= n; ++i) {
-                foff = align_foff_up(foff, ainfo[i - 1].start_addr, PAGE_SIZE);
+        memset(&p_hdr[0], 0, sizeof(p_hdr[0]));
+        p_hdr[0].p_type = PT_NOTE;
+        p_hdr[0].p_offset = foff;
+        p_hdr[0].p_vaddr = 0;
+        p_hdr[0].p_paddr = 0;
+        p_hdr[0].p_filesz = sizeof(elf_note_t)
+            + ALIGN_UP((str_size("CORE") + 1), word_size)
+            + ALIGN_UP(sizeof(elf_prstatus_t), word_size);
+        p_hdr[0].p_memsz = 0;
+        p_hdr[0].p_flags = 0;
+        p_hdr[0].p_align = 1;
+
+        foff += p_hdr[0].p_filesz;
+
+        for (i = 0; i < n; ++i) {
+                foff = align_foff_up(foff, ainfo[i].start_addr, PAGE_SIZE);
 
                 flags = 0;
-                if (ainfo[i - 1].flags & AS_AREA_READ)
+                if (ainfo[i].flags & AS_AREA_READ)
                         flags |= PF_R;
-                if (ainfo[i - 1].flags & AS_AREA_WRITE)
+                if (ainfo[i].flags & AS_AREA_WRITE)
                         flags |= PF_W;
-                if (ainfo[i - 1].flags & AS_AREA_EXEC)
+                if (ainfo[i].flags & AS_AREA_EXEC)
                         flags |= PF_X;
 
-                memset(&p_hdr[i - 1], 0, sizeof(p_hdr[i - 1]));
-                p_hdr[i - 1].p_type = PT_LOAD;
-                p_hdr[i - 1].p_offset = foff;
-                p_hdr[i - 1].p_vaddr = ainfo[i - 1].start_addr;
-                p_hdr[i - 1].p_paddr = 0;
-                p_hdr[i - 1].p_filesz = ainfo[i - 1].size;
-                p_hdr[i - 1].p_memsz = ainfo[i - 1].size;
-                p_hdr[i - 1].p_flags = flags;
-                p_hdr[i - 1].p_align = PAGE_SIZE;
-
-                foff += ainfo[i - 1].size;
+                memset(&p_hdr[i + 1], 0, sizeof(p_hdr[i + 1]));
+                p_hdr[i + 1].p_type = PT_LOAD;
+                p_hdr[i + 1].p_offset = foff;
+                p_hdr[i + 1].p_vaddr = ainfo[i].start_addr;
+                p_hdr[i + 1].p_paddr = 0;
+                p_hdr[i + 1].p_filesz = ainfo[i].size;
+                p_hdr[i + 1].p_memsz = ainfo[i].size;
+                p_hdr[i + 1].p_flags = flags;
+                p_hdr[i + 1].p_align = PAGE_SIZE;
+
+                foff += ainfo[i].size;
         }
 
         rc = write_all(fd, &elf_hdr, sizeof(elf_hdr));
-        if (rc != EOK) {
+        if (rc != sizeof(elf_hdr)) {
                 printf("Failed writing ELF header.\n");
                 free(p_hdr);
@@ -176 +216 @@
         for (i = 0; i < n_ph; ++i) {
                 rc = write_all(fd, &p_hdr[i], sizeof(p_hdr[i]));
-                if (rc != EOK) {
+                if (rc != sizeof(p_hdr[i])) {
                         printf("Failed writing program header.\n");
                         free(p_hdr);
@@ -183 +223 @@
         }
 
-        for (i = 0; i < n_ph; ++i) {
+        if (lseek(fd, p_hdr[0].p_offset, SEEK_SET) == (off64_t) -1) {
+                printf("Failed writing memory data.\n");
+                free(p_hdr);
+                return EIO;
+        }
+
+        /*
+         * Write note header
+         */
+        note.namesz = str_size("CORE") + 1;
+        note.descsz = sizeof(elf_prstatus_t);
+        note.type = NT_PRSTATUS;
+
+        rc = write_all(fd, &note, sizeof(elf_note_t));
+        if (rc != sizeof(elf_note_t)) {
+                printf("Failed writing note header.\n");
+                free(p_hdr);
+                return EIO;
+        }
+
+        rc = write_all(fd, "CORE", note.namesz);
+        if (rc != (ssize_t) note.namesz) {
+                printf("Failed writing note header.\n");
+                free(p_hdr);
+                return EIO;
+        }
+
+        rc = align_pos(fd, word_size);
+        if (rc != EOK) {
+                printf("Failed writing note header.\n");
+                free(p_hdr);
+                return EIO;
+        }
+
+        rc = write_all(fd, &pr_status, sizeof(elf_prstatus_t));
+        if (rc != sizeof(elf_prstatus_t)) {
+                printf("Failed writing register data.\n");
+                free(p_hdr);
+                return EIO;
+        }
+
+        for (i = 1; i < n_ph; ++i) {
                 if (lseek(fd, p_hdr[i].p_offset, SEEK_SET) == (off64_t) -1) {
                         printf("Failed writing memory data.\n");
@@ -189 +270 @@
                         return EIO;
                 }
-                if (write_mem_area(fd, &ainfo[i], phoneid) != EOK) {
+                if (write_mem_area(fd, &ainfo[i - 1], sess) != EOK) {
                         printf("Failed writing memory data.\n");
                         free(p_hdr);
@@ -206 +287 @@
         off64_t rva = vaddr % page_size;
         off64_t rfo = foff % page_size;
-        
+
         if (rva >= rfo)
                 return (foff + (rva - rfo));
-        
+
         return (foff + (page_size + (rva - rfo)));
 }
@@ -215 +296 @@
 /** Write memory area from application to core file.
  *
- * @param fd            File to write to.
- * @param area          Memory area info structure.
- * @param phoneid       Debugging phone.
- *
- * @return              EOK on success, EIO on failure.
- */
-static int write_mem_area(int fd, as_area_info_t *area, int phoneid)
+ * @param fd   File to write to.
+ * @param area Memory area info structure.
+ * @param sess Debugging session.
+ *
+ * @return EOK on success, EIO on failure.
+ *
+ */
+static int write_mem_area(int fd, as_area_info_t *area, async_sess_t *sess)
 {
         size_t to_copy;
         size_t total;
         uintptr_t addr;
-        int rc;
+        ssize_t rc;
 
         addr = area->start_addr;
@@ -233 +315 @@
         while (total < area->size) {
                 to_copy = min(area->size - total, BUFFER_SIZE);
-                rc = udebug_mem_read(phoneid, buffer, addr, to_copy);
+                rc = udebug_mem_read(sess, buffer, addr, to_copy);
                 if (rc < 0) {
                         printf("Failed reading task memory.\n");
@@ -240 +322 @@
 
                 rc = write_all(fd, buffer, to_copy);
-                if (rc != EOK) {
+                if (rc != (ssize_t) to_copy) {
                         printf("Failed writing memory contents.\n");
                         return EIO;
@@ -252 +334 @@
 }
 
-/** Write until the buffer is written in its entirety.
- *
- * This function fails if it cannot write exactly @a len bytes to the file.
- *
- * @param fd            The file to write to.
- * @param buf           Data, @a len bytes long.
- * @param len           Number of bytes to write.
- *
- * @return              EOK on error, return value from write() if writing
- *                      failed.
- */
-static int write_all(int fd, void *data, size_t len)
+static int align_pos(int fd, size_t align)
 {
-        int cnt = 0;
-
-        do {
-                data += cnt;
-                len -= cnt;
-                cnt = write(fd, data, len);
-        } while (cnt > 0 && (len - cnt) > 0);
-
-        if (cnt < 0)
-                return cnt;
-
-        if (len - cnt > 0)
-                return EIO;
+        off64_t cur_pos;
+        size_t rem, adv;
+
+        cur_pos = lseek(fd, 0, SEEK_CUR);
+        if (cur_pos < 0)
+                return -1;
+
+        rem = cur_pos % align;
+        adv = align - rem;
+
+        cur_pos = lseek(fd, adv, SEEK_CUR);
+        if (cur_pos < 0)
+                return -1;
 
         return EOK;
 }
 
-
 /** @}
  */