Changeset 056d6821 in mainline for uspace/app

Timestamp:

2011-07-26T21:17:29Z (15 years ago)

Author:

Petr Koupy <petr.koupy@…>

Branches:

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

Children:

051e6ac, 0837ab4

Parents:

2f02ee25 (diff), 75aa59a (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 mainline changes.

Location:

uspace/app

Files:

• bdsh/cmds/modules/cp/cp.c (modified) (2 diffs)
• bdsh/cmds/modules/ls/ls.c (modified) (1 diff)
• bdsh/compl.c (modified) (1 diff)
• bdsh/exec.c (modified) (1 diff)
• bdsh/input.c (modified) (1 diff)
• init/init.c (modified) (1 diff)
• taskdump/elf_core.c (modified) (14 diffs)
• taskdump/include/elf.h (deleted)
• taskdump/include/elf_core.h (modified) (1 diff)
• taskdump/include/symtab.h (modified) (1 diff)
• taskdump/symtab.c (modified) (8 diffs)
• taskdump/taskdump.c (modified) (4 diffs)

uspace/app/bdsh/cmds/modules/cp/cp.c

@@ -71 +71 @@
         size_t blen, int vb)
 {
-        int fd1, fd2, bytes = 0;
-        off64_t total = 0;
+        int fd1, fd2, bytes;
+        off64_t total;
         int64_t copied = 0;
         char *buff = NULL;
@@ -104 +104 @@
         }
 
-        for (;;) {
-                ssize_t res;
-                size_t written = 0;
-
-                bytes = read(fd1, buff, blen);
-                if (bytes <= 0)
+        while ((bytes = read_all(fd1, buff, blen)) > 0) {
+                if ((bytes = write_all(fd2, buff, bytes)) < 0)
                         break;
                 copied += bytes;
-                res = bytes;
-                do {
-                        /*
-                         * Theoretically, it may not be enough to call write()
-                         * only once. Also the previous read() may have
-                         * returned less data than requested.
-                         */
-                        bytes = write(fd2, buff + written, res);
-                        if (bytes < 0)
-                                goto err;
-                        written += bytes;
-                        res -= bytes;
-                } while (res > 0);
-
-                /* TODO: re-insert assert() once this is stand alone,
-                 * removed as abort() exits the entire shell
-                 */
-                if (res != 0) {
-                        printf("\n%zd more bytes than actually exist were copied\n", res);
-                        goto err;
-                }
         }
 
         if (bytes < 0) {
-err:
                 printf("\nError copying %s, (%d)\n", src, bytes);
                 copied = bytes;

uspace/app/bdsh/cmds/modules/ls/ls.c

@@ -169 +169 @@
                 
                 /* fill the name field */
-                tosort[nbdirs].name = (char *) malloc(str_length(dp->d_name) + 1);
+                tosort[nbdirs].name = (char *) malloc(str_size(dp->d_name) + 1);
                 if (!tosort[nbdirs].name) {
                         cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
                         goto out;
                 }
-                
-                str_cpy(tosort[nbdirs].name, str_length(dp->d_name) + 1, dp->d_name);
+
+                str_cpy(tosort[nbdirs].name, str_size(dp->d_name) + 1, dp->d_name);
                 len = snprintf(buff, PATH_MAX - 1, "%s/%s", d, tosort[nbdirs].name);
                 buff[len] = '\0';

uspace/app/bdsh/compl.c

@@ -280 +280 @@
 
                                 cs->dir = opendir(*cs->path);
+
+                                /* Skip directories that we fail to open. */
+                                if (cs->dir == NULL)
+                                        cs->path++;
                         }
 

uspace/app/bdsh/exec.c

@@ -52 +52 @@
 static int try_access(const char *);
 
-const char *search_dir[] = { "app", "srv", NULL };
+const char *search_dir[] = { "/app", "/srv", NULL };
 
 /* work-around for access() */

uspace/app/bdsh/input.c

@@ -170 +170 @@
         }
         
-        rc = run_command(cmd, usr, &new_iostate);
+        rc = run_command(actual_cmd, usr, &new_iostate);
         
 finit_with_files:

uspace/app/init/init.c

@@ -294 +294 @@
         
 #ifdef CONFIG_MOUNT_DATA
+        /* Make sure fat is running. */
+        if (str_cmp(STRING(RDFMT), "fat") != 0) {
+                srv_start("/srv/fat");
+        }
         mount_data();
 #else

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"
+#include <libarch/istate.h>
+
+#include "elf_core.h"
 
 static off64_t align_foff_up(off64_t, uintptr_t, size_t);
-static int write_all(int, void *, size_t);
+static int align_pos(int, size_t);
 static int write_mem_area(int, as_area_info_t *, async_sess_t *);
 
@@ -83 +87 @@
  */
 int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n,
-    async_sess_t *sess)
+    async_sess_t *sess, istate_t *istate)
 {
         elf_header_t elf_hdr;
@@ -90 +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__
+        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);
         if (p_hdr == NULL) {
                 printf("Failed allocating memory.\n");
@@ -115 +131 @@
          *      ELF header
          *      program headers
+         *      note segment
          * repeat:
          *      (pad for alignment)
-         *      segment data
+         *      core segment
          * end repeat
          */
@@ -147 +164 @@
         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);
@@ -180 +211 @@
         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);
@@ -187 +218 @@
         }
 
-        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");
@@ -193 +265 @@
                         return EIO;
                 }
-                if (write_mem_area(fd, &ainfo[i], sess) != EOK) {
+                if (write_mem_area(fd, &ainfo[i - 1], sess) != EOK) {
                         printf("Failed writing memory data.\n");
                         free(p_hdr);
@@ -210 +282 @@
         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)));
 }
@@ -231 +303 @@
         size_t total;
         uintptr_t addr;
-        int rc;
+        ssize_t rc;
 
         addr = area->start_addr;
@@ -245 +317 @@
 
                 rc = write_all(fd, buffer, to_copy);
-                if (rc != EOK) {
+                if (rc != (ssize_t) to_copy) {
                         printf("Failed writing memory contents.\n");
                         return EIO;
@@ -257 +329 @@
 }
 
-/** 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;
 }
 
-
 /** @}
  */

uspace/app/taskdump/include/elf_core.h

@@ -37 +37 @@
 
 #include <async.h>
+#include <elf/elf_linux.h>
+#include <libarch/istate.h>
 
 extern int elf_core_save(const char *, as_area_info_t *, unsigned int,
-    async_sess_t *);
+    async_sess_t *, istate_t *);
 
 #endif

uspace/app/taskdump/include/symtab.h

@@ -36 +36 @@
 #define SYMTAB_H_
 
+#include <elf/elf.h>
 #include <sys/types.h>
-#include <elf.h>
 
 typedef struct {

uspace/app/taskdump/symtab.c

@@ -36 +36 @@
  */
 
+#include <elf/elf.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -43 +44 @@
 #include <fcntl.h>
 
-#include <elf.h>
 #include "include/symtab.h"
 
@@ -50 +50 @@
     elf_section_header_t *shdr);
 static int chunk_load(int fd, off64_t start, size_t size, void **ptr);
-static int read_all(int fd, void *buf, size_t len);
 
 /** Load symbol table from an ELF file.
@@ -90 +89 @@
 
         rc = read_all(fd, &elf_hdr, sizeof(elf_header_t));
-        if (rc != EOK) {
+        if (rc != sizeof(elf_header_t)) {
                 printf("failed reading elf header\n");
                 free(stab);
@@ -312 +311 @@
 
         rc = read_all(fd, sec_hdr, sizeof(elf_section_header_t));
-        if (rc != EOK)
+        if (rc != sizeof(elf_section_header_t))
                 return EIO;
 
@@ -331 +330 @@
 static int chunk_load(int fd, off64_t start, size_t size, void **ptr)
 {
-        int rc;
-
-        rc = lseek(fd, start, SEEK_SET);
-        if (rc == (off64_t) -1) {
+        ssize_t rc;
+        off64_t offs;
+
+        offs = lseek(fd, start, SEEK_SET);
+        if (offs == (off64_t) -1) {
                 printf("failed seeking chunk\n");
                 *ptr = NULL;
@@ -347 +347 @@
 
         rc = read_all(fd, *ptr, size);
-        if (rc != EOK) {
+        if (rc != (ssize_t) size) {
                 printf("failed reading chunk\n");
                 free(*ptr);
@@ -357 +357 @@
 }
 
-/** Read until the buffer is read in its entirety.
- *
- * This function fails if it cannot read exactly @a len bytes from the file.
- *
- * @param fd            The file to read from.
- * @param buf           Buffer for storing data, @a len bytes long.
- * @param len           Number of bytes to read.
- *
- * @return              EOK on error, EIO if file is short or return value
- *                      from read() if reading failed.
- */
-static int read_all(int fd, void *buf, size_t len)
-{
-        int cnt = 0;
-
-        do {
-                buf += cnt;
-                len -= cnt;
-                cnt = read(fd, buf, len);
-        } while (cnt > 0 && (len - cnt) > 0);
-
-        if (cnt < 0)
-                return cnt;
-
-        if (len - cnt > 0)
-                return EIO;
-
-        return EOK;
-}
-
 /** @}
  */

uspace/app/taskdump/taskdump.c

@@ -34 +34 @@
 
 #include <async.h>
+#include <elf/elf_linux.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -72 +73 @@
 static char *get_app_task_name(void);
 static char *fmt_sym_address(uintptr_t addr);
+
+static istate_t reg_state;
 
 int main(int argc, char *argv[])
@@ -293 +296 @@
         if (write_core_file) {
                 printf("Writing core file '%s'\n", core_file_name);
-                rc = elf_core_save(core_file_name, ainfo_buf, n_areas, sess);
+
+                rc = elf_core_save(core_file_name, ainfo_buf, n_areas, sess,
+                    &reg_state);
+
                 if (rc != EOK) {
                         printf("Failed writing core file.\n");
@@ -321 +327 @@
         pc = istate_get_pc(&istate);
         fp = istate_get_fp(&istate);
+
+        /* Save register state for dumping to core file later. */
+        reg_state = istate;
 
         sym_pc = fmt_sym_address(pc);