Changes in uspace/app/taskdump/elf_core.c [8fd04ba9:79ae36dd] in mainline

File:

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

uspace/app/taskdump/elf_core.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2010 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 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>
+ * 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.
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
@@ -62 +58 @@
 #include <udebug.h>
 #include <macros.h>
-#include <libarch/istate.h>
-
-#include "elf_core.h"
+
+#include <elf.h>
+#include "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_all(int, void *, size_t);
 static int write_mem_area(int, as_area_info_t *, async_sess_t *);
 
@@ -87 +83 @@
  */
 int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n,
-    async_sess_t *sess, istate_t *istate)
+    async_sess_t *sess)
 {
         elf_header_t elf_hdr;
@@ -94 +90 @@
         elf_word flags;
         elf_segment_header_t *p_hdr;
-        elf_prstatus_t pr_status;
-        elf_note_t note;
-        size_t word_size;
 
         int fd;
-        ssize_t rc;
+        int rc;
         unsigned int i;
 
-#ifdef __32_BITS__
-        word_size = 4;
-#endif
-#ifdef __64_BITS__
-        word_size = 8;
-#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);
+        n_ph = n;
+
+        p_hdr = malloc(sizeof(elf_segment_header_t) * n);
         if (p_hdr == NULL) {
                 printf("Failed allocating memory.\n");
@@ -131 +115 @@
          *      ELF header
          *      program headers
-         *      note segment
          * repeat:
          *      (pad for alignment)
-         *      core segment
+         *      segment data
          * end repeat
          */
@@ -164 +147 @@
         foff = elf_hdr.e_phoff + n_ph * sizeof(elf_segment_header_t);
 
-        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);
+        for (i = 1; i <= n; ++i) {
+                foff = align_foff_up(foff, ainfo[i - 1].start_addr, PAGE_SIZE);
 
                 flags = 0;
-                if (ainfo[i].flags & AS_AREA_READ)
+                if (ainfo[i - 1].flags & AS_AREA_READ)
                         flags |= PF_R;
-                if (ainfo[i].flags & AS_AREA_WRITE)
+                if (ainfo[i - 1].flags & AS_AREA_WRITE)
                         flags |= PF_W;
-                if (ainfo[i].flags & AS_AREA_EXEC)
+                if (ainfo[i - 1].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].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;
+                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;
         }
 
         rc = write_all(fd, &elf_hdr, sizeof(elf_hdr));
-        if (rc != sizeof(elf_hdr)) {
+        if (rc != EOK) {
                 printf("Failed writing ELF header.\n");
                 free(p_hdr);
@@ -211 +180 @@
         for (i = 0; i < n_ph; ++i) {
                 rc = write_all(fd, &p_hdr[i], sizeof(p_hdr[i]));
-                if (rc != sizeof(p_hdr[i])) {
+                if (rc != EOK) {
                         printf("Failed writing program header.\n");
                         free(p_hdr);
@@ -218 +187 @@
         }
 
-        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) {
+        for (i = 0; i < n_ph; ++i) {
                 if (lseek(fd, p_hdr[i].p_offset, SEEK_SET) == (off64_t) -1) {
                         printf("Failed writing memory data.\n");
@@ -265 +193 @@
                         return EIO;
                 }
-                if (write_mem_area(fd, &ainfo[i - 1], sess) != EOK) {
+                if (write_mem_area(fd, &ainfo[i], sess) != EOK) {
                         printf("Failed writing memory data.\n");
                         free(p_hdr);
@@ -282 +210 @@
         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)));
 }
@@ -303 +231 @@
         size_t total;
         uintptr_t addr;
-        ssize_t rc;
+        int rc;
 
         addr = area->start_addr;
@@ -317 +245 @@
 
                 rc = write_all(fd, buffer, to_copy);
-                if (rc != (ssize_t) to_copy) {
+                if (rc != EOK) {
                         printf("Failed writing memory contents.\n");
                         return EIO;
@@ -329 +257 @@
 }
 
-static int align_pos(int fd, size_t align)
-{
-        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;
+/** 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)
+{
+        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;
 
         return EOK;
 }
 
+
 /** @}
  */