Changeset 3fb0fec – HelenOS

HelenOS.config

refcebe1	r3fb0fec
88	88	@ "tmpfs" TMPFS image
89	89	@ "fat" FAT16 image
	90	@ "ext2fs" EXT2 image
90	91	! RDFMT (choice)
91	92

boot/Makefile

-              refcebe1
+              r3fb0fec
         $(MKFAT) 1048576 $(DIST_PATH) $@
 endif
+ifeq ($(RDFMT),ext2fs)
+        $(MKEXT2) 1048576 $(DIST_PATH) $@
+endif
 build_dist: clean_dist

boot/Makefile.common

-              refcebe1
+              r3fb0fec
 MKTMPFS = $(TOOLS_PATH)/mktmpfs.py
 MKFAT = $(TOOLS_PATH)/mkfat.py
+MKEXT2 = $(TOOLS_PATH)/mkext2.py
 MKUIMAGE = $(TOOLS_PATH)/mkuimage.py
 …
 ifeq ($(RDFMT),fat)
         INIT_TASKS += $(USPACE_PATH)/srv/fs/fat/fat
+endif
+ifeq ($(RDFMT),ext2fs)
+        INIT_TASKS += $(USPACE_PATH)/srv/fs/ext2fs/ext2fs
 endif

kernel/generic/include/lib/elf.h

-              refcebe1
+              r3fb0fec
  * current ELF version
  */
 #define EV_CURRENT  1
+#define EV_CURRENT      1
 /**
  * ELF types
  */
 #define ET_NONE    0       /* No type */
 #define ET_REL     1       /* Relocatable file */
 #define ET_EXEC    2       /* Executable */
 #define ET_DYN     3       /* Shared object */
 #define ET_CORE    4       /* Core */
 #define ET_LOPROC  0xff00  /* Processor specific */
 #define ET_HIPROC  0xffff  /* Processor specific */
+#define ET_NONE         0       /* No type */
+#define ET_REL          1       /* Relocatable file */
+#define ET_EXEC         2       /* Executable */
+#define ET_DYN          3       /* Shared object */
+#define ET_CORE         4       /* Core */
+#define ET_LOPROC       0xff00  /* Processor specific */
+#define ET_HIPROC       0xffff  /* Processor specific */
 /**
  * ELF machine types
  */
 #define EM_NO           0   /* No machine */
 #define EM_SPARC        2   /* SPARC */
 #define EM_386          3   /* i386 */
 #define EM_MIPS         8   /* MIPS RS3000 */
 #define EM_MIPS_RS3_LE  10  /* MIPS RS3000 LE */
 #define EM_PPC          20  /* PPC32 */
 #define EM_PPC64        21  /* PPC64 */
 #define EM_ARM          40  /* ARM */
 #define EM_SPARCV9      43  /* SPARC64 */
 #define EM_IA_64        50  /* IA-64 */
 #define EM_X86_64       62  /* AMD64/EMT64 */
+#define EM_NO           0       /* No machine */
+#define EM_SPARC        2       /* SPARC */
+#define EM_386          3       /* i386 */
+#define EM_MIPS         8       /* MIPS RS3000 */
+#define EM_MIPS_RS3_LE  10      /* MIPS RS3000 LE */
+#define EM_PPC          20      /* PPC32 */
+#define EM_PPC64        21      /* PPC64 */
+#define EM_ARM          40      /* ARM */
+#define EM_SPARCV9      43      /* SPARC64 */
+#define EM_IA_64        50      /* IA-64 */
+#define EM_X86_64       62      /* AMD64/EMT64 */
 /**
  * ELF identification indexes
  */
 #define EI_MAG0        0
 #define EI_MAG1        1
 #define EI_MAG2        2
 #define EI_MAG3        3
 #define EI_CLASS       4   /* File class */
 #define EI_DATA        5   /* Data encoding */
 #define EI_VERSION     6   /* File version */
 #define EI_OSABI       7
 #define EI_ABIVERSION  8
 #define EI_PAD         9   /* Start of padding bytes */
 #define EI_NIDENT      16  /* ELF identification table size */
+#define EI_MAG0         0
+#define EI_MAG1         1
+#define EI_MAG2         2
+#define EI_MAG3         3
+#define EI_CLASS        4               /* File class */
+#define EI_DATA         5               /* Data encoding */
+#define EI_VERSION      6               /* File version */
+#define EI_OSABI        7
+#define EI_ABIVERSION   8
+#define EI_PAD          9               /* Start of padding bytes */
+#define EI_NIDENT       16              /* ELF identification table size */
 /**
  * ELF magic number
  */
 #define ELFMAG0  0x7f
 #define ELFMAG1  'E'
 #define ELFMAG2  'L'
 #define ELFMAG3  'F'
+#define ELFMAG0         0x7f
+#define ELFMAG1         'E'
+#define ELFMAG2         'L'
+#define ELFMAG3         'F'
 /**
  * ELF file classes
  */
 #define ELFCLASSNONE  0
 #define ELFCLASS32    1
 #define ELFCLASS64    2
+#define ELFCLASSNONE    0
+#define ELFCLASS32      1
+#define ELFCLASS64      2
 /**
  * ELF data encoding types
  */
+#define ELFDATANONE  0
+#define ELFDATA2LSB  1  /* Least significant byte first (little endian) */
+#define ELFDATA2MSB  2  /* Most signigicant byte first (big endian) */
+/**
+ * ELF error return codes
+ */
+#define EE_OK             0  /* No error */
+#define EE_INVALID        1  /* Invalid ELF image */
+#define EE_MEMORY         2  /* Cannot allocate address space */
+#define EE_INCOMPATIBLE   3  /* ELF image is not compatible with current architecture */
+#define EE_UNSUPPORTED    4  /* Non-supported ELF (e.g. dynamic ELFs) */
+#define EE_LOADER         5  /* The image is actually a program loader */
+#define EE_IRRECOVERABLE  6
+#define ELFDATANONE     0
+#define ELFDATA2LSB     1               /* Least significant byte first (little endian) */
+#define ELFDATA2MSB     2               /* Most signigicant byte first (big endian) */
 /**
  * ELF section types
  */
 #define SHT_NULL      0
 #define SHT_PROGBITS  1
 #define SHT_SYMTAB    2
 #define SHT_STRTAB    3
 #define SHT_RELA      4
 #define SHT_HASH      5
 #define SHT_DYNAMIC   6
 #define SHT_NOTE      7
 #define SHT_NOBITS    8
 #define SHT_REL       9
 #define SHT_SHLIB     10
 #define SHT_DYNSYM    11
 #define SHT_LOOS      0x60000000
 #define SHT_HIOS      0x6fffffff
 #define SHT_LOPROC    0x70000000
 #define SHT_HIPROC    0x7fffffff
 #define SHT_LOUSER    0x80000000
 #define SHT_HIUSER    0xffffffff
+#define SHT_NULL                0
+#define SHT_PROGBITS            1
+#define SHT_SYMTAB              2
+#define SHT_STRTAB              3
+#define SHT_RELA                4
+#define SHT_HASH                5
+#define SHT_DYNAMIC             6
+#define SHT_NOTE                7
+#define SHT_NOBITS              8
+#define SHT_REL                 9
+#define SHT_SHLIB               10
+#define SHT_DYNSYM              11
+#define SHT_LOOS                0x60000000
+#define SHT_HIOS                0x6fffffff
+#define SHT_LOPROC              0x70000000
+#define SHT_HIPROC              0x7fffffff
+#define SHT_LOUSER              0x80000000
+#define SHT_HIUSER              0xffffffff
 /**
  * ELF section flags
  */
+#define SHF_WRITE      0x1
+#define SHF_ALLOC      0x2
+#define SHF_EXECINSTR  0x4
+#define SHF_TLS        0x400
+#define SHF_MASKPROC   0xf0000000
+#define SHF_WRITE               0x1
+#define SHF_ALLOC               0x2
+#define SHF_EXECINSTR           0x4
+#define SHF_TLS                 0x400
+#define SHF_MASKPROC            0xf0000000
+/** Macros for decomposing elf_symbol.st_info into binging and type */
+#define ELF_ST_BIND(i)          ((i) >> 4)
+#define ELF_ST_TYPE(i)          ((i) & 0x0f)
+#define ELF_ST_INFO(b, t)       (((b) << 4) + ((t) & 0x0f))
 /**
  * Symbol binding
  */
 #define STB_LOCAL   0
 #define STB_GLOBAL  1
 #define STB_WEAK    2
 #define STB_LOPROC  13
 #define STB_HIPROC  15
+#define STB_LOCAL               0
+#define STB_GLOBAL              1
+#define STB_WEAK                2
+#define STB_LOPROC              13
+#define STB_HIPROC              15
 /**
  * Symbol types
  */
 #define STT_NOTYPE   0
 #define STT_OBJECT   1
 #define STT_FUNC     2
 #define STT_SECTION  3
 #define STT_FILE     4
 #define STT_LOPROC   13
 #define STT_HIPROC   15
+#define STT_NOTYPE              0
+#define STT_OBJECT              1
+#define STT_FUNC                2
+#define STT_SECTION             3
+#define STT_FILE                4
+#define STT_LOPROC              13
+#define STT_HIPROC              15
 /**
  * Program segment types
  */
 #define PT_NULL     0
 #define PT_LOAD     1
 #define PT_DYNAMIC  2
 #define PT_INTERP   3
 #define PT_NOTE     4
 #define PT_SHLIB    5
 #define PT_PHDR     6
 #define PT_LOPROC   0x70000000
 #define PT_HIPROC   0x7fffffff
+#define PT_NULL                 0
+#define PT_LOAD                 1
+#define PT_DYNAMIC              2
+#define PT_INTERP               3
+#define PT_NOTE                 4
+#define PT_SHLIB                5
+#define PT_PHDR                 6
+#define PT_LOPROC               0x70000000
+#define PT_HIPROC               0x7fffffff
 /**
  * Program segment attributes.
  */
 #define PF_X  1
 #define PF_W  2
 #define PF_R  4
+#define PF_X    1
+#define PF_W    2
+#define PF_R    4
 /**
 …
  * ELF object file specifications. They are the only types used
  * in ELF header.
+ *
  */
 typedef uint64_t elf_xword;
 …
+ *
  * These types are specific for 32-bit format.
+ *
  */
 typedef uint32_t elf32_addr;
 …
+ *
  * These types are specific for 64-bit format.
+ *
  */
 typedef uint64_t elf64_addr;
 …
         elf_half e_shstrndx;
 };
 struct elf64_header {
         uint8_t e_ident[EI_NIDENT];
 …
 };
 /**
+/*
  * ELF segment header.
  * Segments headers are also known as program headers.
 …
         elf_word p_align;
 };
 struct elf64_segment_header {
         elf_word p_type;
 …
 };
 /**
+/*
  * ELF section header
  */
 …
         elf_word sh_entsize;
 };
 struct elf64_section_header {
         elf_word sh_name;
 …
 };
 /**
+/*
  * ELF symbol table entry
  */
 …
         elf_half st_shndx;
 };
 struct elf64_symbol {
         elf_word st_name;
 …
 };
+/*
+ * ELF note segment entry
+ */
+struct elf32_note {
+        elf_word namesz;
+        elf_word descsz;
+        elf_word type;
+};
+struct elf64_note {
+        elf_xword namesz;
+        elf_xword descsz;
+        elf_xword type;
+};
 #ifdef __32_BITS__
 typedef struct elf32_header elf_header_t;
 …
 typedef struct elf32_section_header elf_section_header_t;
 typedef struct elf32_symbol elf_symbol_t;
+typedef struct elf32_note elf_note_t;
 #endif
 #ifdef __64_BITS__
 typedef struct elf64_header elf_header_t;
 …
 typedef struct elf64_section_header elf_section_header_t;
 typedef struct elf64_symbol elf_symbol_t;
+typedef struct elf64_note elf_note_t;
 #endif
-extern const char *elf_error(unsigned int rc);
 /** Interpreter string used to recognize the program loader */

kernel/generic/include/mm/as.h

-              refcebe1
+              r3fb0fec
 extern mem_backend_t phys_backend;
-/**
- * This flags is passed when running the loader, otherwise elf_load()
- * would return with a EE_LOADER error code.
+ *
- */
-#define ELD_F_NONE    0
-#define ELD_F_LOADER  1
-extern unsigned int elf_load(elf_header_t *, as_t *, unsigned int);
 /* Address space area related syscalls. */
 extern sysarg_t sys_as_area_create(uintptr_t, size_t, unsigned int);

kernel/generic/src/lib/elf.c

refcebe1	r3fb0fec
47	47	#include <macros.h>
48	48	#include <arch.h>
	49
	50	#include <lib/elf_load.h>
49	51
50	52	static const char *error_codes[] = {

kernel/generic/src/proc/program.c

refcebe1	r3fb0fec
48	48	#include <ipc/ipcrsc.h>
49	49	#include <security/cap.h>
50		#include <lib/elf.h>
	50	#include <lib/elf_load.h>
51	51	#include <errno.h>
52	52	#include <print.h>

tools/mkfat.py

-              refcebe1
+              r3fb0fec
 import xstruct
 import array
+exclude_names = set(['.svn', '.bzr'])
+def align_up(size, alignment):
+        "Return size aligned up to alignment"
+        if (size % alignment == 0):
+                return size
+        return ((size // alignment) + 1) * alignment
+from imgutil import *
 def subtree_size(root, cluster_size, dirent_size):
 …
         files = 2
+        for name in os.listdir(root):
+                canon = os.path.join(root, name)
+                if (os.path.isfile(canon) and (not name in exclude_names)):
+                        size += align_up(os.path.getsize(canon), cluster_size)
+        for item in listdir_items(root):
+                if item.is_file:
+                        size += align_up(item.size, cluster_size)
                         files += 1
+                if (os.path.isdir(canon) and (not name in exclude_names)):
+                        size += subtree_size(canon, cluster_size, dirent_size)
+                elif item.is_dir:
+                        size += subtree_size(item.path, cluster_size, dirent_size)
                         files += 1
 …
         return len(os.listdir(root))
 def write_file(path, outf, cluster_size, data_start, fat, reserved_clusters):
+def write_file(item, outf, cluster_size, data_start, fat, reserved_clusters):
         "Store the contents of a file"
-        size = os.path.getsize(path)
         prev = -1
         first = 0
+        inf = open(path, "rb")
+        rd = 0;
+        while (rd < size):
+        for data in chunks(item, cluster_size):
                 empty_cluster = fat.index(0)
                 fat[empty_cluster] = 0xffff
 …
                 prev = empty_cluster
-                data = bytes(inf.read(cluster_size));
                 outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
                 outf.write(data)
+                rd += len(data)
+        inf.close()
+        return first, size
+        return first, item.size
 def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):
 …
                 empty_cluster = 0
+        for name in os.listdir(root):
+                canon = os.path.join(root, name)
+                if (os.path.isfile(canon) and (not name in exclude_names)):
+                        rv = write_file(canon, outf, cluster_size, data_start, fat, reserved_clusters)
+                        directory.append(create_dirent(name, False, rv[0], rv[1]))
+                if (os.path.isdir(canon) and (not name in exclude_names)):
+                        rv = recursion(False, canon, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
+                        directory.append(create_dirent(name, True, rv[0], rv[1]))
+        for item in listdir_items(root):
+                if item.is_file:
+                        rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
+                        directory.append(create_dirent(item.name, False, rv[0], rv[1]))
+                elif item.is_dir:
+                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
+                        directory.append(create_dirent(item.name, True, rv[0], rv[1]))
         if (head):

tools/mktmpfs.py

-              refcebe1
+              r3fb0fec
 import os
 import xstruct
+exclude_names = set(['.svn', '.bzr'])
+from imgutil import listdir_items, chunks
 HEADER = """little:
 …
         "Recursive directory walk"
+        for name in os.listdir(root):
+                canon = os.path.join(root, name)
+                if (os.path.isfile(canon) and (not name in exclude_names)):
+                        size = os.path.getsize(canon)
+                        dentry = xstruct.create(DENTRY_FILE % len(name))
+        for item in listdir_items(root):
+                if item.is_file:
+                        dentry = xstruct.create(DENTRY_FILE % len(item.name))
                         dentry.kind = TMPFS_FILE
                         dentry.fname_len = len(name)
                         dentry.fname = name.encode('ascii')
                         dentry.flen = size
+                        dentry.fname_len = len(item.name)
+                        dentry.fname = item.name.encode('ascii')
+                        dentry.flen = item.size
                         outf.write(dentry.pack())
+                        inf = open(canon, "rb")
+                        rd = 0;
+                        while (rd < size):
+                                data = inf.read(4096);
+                        for data in chunks(item, 4096):
                                 outf.write(data)
-                                rd += len(data)
-                        inf.close()
                 if (os.path.isdir(canon) and (not name in exclude_names)):
                         dentry = xstruct.create(DENTRY_DIRECTORY % len(name))
+                elif item.is_dir:
+                        dentry = xstruct.create(DENTRY_DIRECTORY % len(item.name))
                         dentry.kind = TMPFS_DIRECTORY
                         dentry.fname_len = len(name)
                         dentry.fname = name.encode('ascii')
+                        dentry.fname_len = len(item.name)
+                        dentry.fname = item.name.encode('ascii')
                         outf.write(dentry.pack())
                         recursion(canon, outf)
+                        recursion(item.path, outf)
                         dentry = xstruct.create(DENTRY_NONE)

tools/xstruct.py

-              refcebe1
+              r3fb0fec
+#
 # Copyright (c) 2008 Martin Decky
+# Copyright (c) 2011 Martin Sucha
 # All rights reserved.
+#
 …
 import struct
+import types
+ranges = {
+        'B': ((int, long), 0x00, 0xff),
+        'H': ((int, long), 0x0000, 0xffff),
+        'L': ((int, long), 0x00000000, 0xffffffff),
+        'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
+        'b': ((int, long), -0x80, 0x7f),
+        'h': ((int, long), -0x8000, 0x7fff),
+        'l': ((int, long), -0x80000000, 0x7fffffff) ,
+        'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
+}
+def check_range(varname, fmt, value):
+        if value == None:
+                raise ValueError('Variable "%s" not set' % varname)
+        if not fmt in ranges:
+                return
+        vartype, varmin, varmax = ranges[fmt]
+        if not isinstance(value, vartype):
+                raise ValueError('Variable "%s" is %s but should be %s' %
+                                 (varname, str(type(value)), str(vartype)))
+        if value < varmin or value > varmax:
+                raise ValueError('Variable "%s" value %s out of range %s..%s' %
+                                 (varname, repr(value), repr(varmin), repr(varmax)))
 class Struct:
 …
         def pack(self):
                 args = []
+                for variable in self._args_:
+                        if (isinstance(self.__dict__[variable], list)):
+                                for item in self.__dict__[variable]:
+                for variable, fmt, length in self._args_:
+                        value = self.__dict__[variable]
+                        if isinstance(value, list):
+                                if length != None and length != len(value):
+                                        raise ValueError('Variable "%s" length %u does not match %u' %
+                                                      (variable, len(value), length))
+                                for index, item in enumerate(value):
+                                        check_range(variable + '[' + repr(index) + ']', fmt, item)
                                         args.append(item)
                         else:
                                 args.append(self.__dict__[variable])
+                                check_range(variable, fmt, value)
+                                args.append(value)
                 return struct.pack(self._format_, *args)
+        def unpack(self, data):
+                values = struct.unpack(self._format_, data)
+                i = 0
+                for variable, fmt, length in self._args_:
+                        self.__dict__[variable] = values[i]
+                        i += 1
 def create(definition):
 …
                         subtokens = token.split("[")
+                        length = None
                         if (len(subtokens) > 1):
+                                format += "%d" % int(subtokens[1].split("]")[0])
+                                length = int(subtokens[1].split("]")[0])
+                                format += "%d" % length
                         format += variable
                         inst.__dict__[subtokens[0]] = None
                         args.append(subtokens[0])
+                        args.append((subtokens[0], variable, length))
                         variable = None

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

-              refcebe1
+              r3fb0fec
         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;
 …
+        }
+        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/compl.c

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

uspace/app/bdsh/exec.c

refcebe1	r3fb0fec
52	52	static int try_access(const char *);
53	53
54		const char *search_dir[] = { "~~app", "~~srv", NULL };
	54	const char *search_dir[] = { "/app", "/srv", NULL };
55	55
56	56	/* work-around for access() */

uspace/app/bdsh/input.c

refcebe1	r3fb0fec
170	170	}
171	171
172		rc = run_command(cmd, usr, &new_iostate);
	172	rc = run_command(actual_cmd, usr, &new_iostate);
173	173
174	174	finit_with_files:

uspace/app/init/init.c

-              refcebe1
+              r3fb0fec
 #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

-              refcebe1
+              r3fb0fec
 /*
  * Copyright (c) 2010 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
+ *
 …
  * 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>
 …
 #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 *);
 …
  */
 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;
 …
         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");
 …
          *      ELF header
          *      program headers
+         *      note segment
          * repeat:
          *      (pad for alignment)
          *      segment data
+         *      core segment
          * end repeat
          */
 …
         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);
 …
         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);
 …
+        }
+        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");
 …
                         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);
 …
         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)));
+}
 …
         size_t total;
         uintptr_t addr;
         int rc;
+        ssize_t rc;
         addr = area->start_addr;
 …
                 rc = write_all(fd, buffer, to_copy);
                 if (rc != EOK) {
+                if (rc != (ssize_t) to_copy) {
                         printf("Failed writing memory contents.\n");
                         return EIO;
 …
+}
+/** 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

-              refcebe1
+              r3fb0fec
 #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

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

uspace/app/taskdump/symtab.c

-              refcebe1
+              r3fb0fec
  */
+#include <elf/elf.h>
 #include <stdio.h>
 #include <stdlib.h>
 …
 #include <fcntl.h>
-#include <elf.h>
 #include "include/symtab.h"
 …
     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.
 …
         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);
 …
         rc = read_all(fd, sec_hdr, sizeof(elf_section_header_t));
         if (rc != EOK)
+        if (rc != sizeof(elf_section_header_t))
                 return EIO;
 …
 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;
 …
         rc = read_all(fd, *ptr, size);
         if (rc != EOK) {
+        if (rc != (ssize_t) size) {
                 printf("failed reading chunk\n");
                 free(*ptr);
 …
+}
-/** 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

-              refcebe1
+              r3fb0fec
 #include <async.h>
+#include <elf/elf_linux.h>
 #include <stdio.h>
 #include <stdlib.h>
 …
 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[])
 …
         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");
 …
         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);

uspace/drv/bus/usb/usbmast/bo_trans.c

-              refcebe1
+              r3fb0fec
  * @param tag           Command block wrapper tag (automatically compared
  *                      with answer)
+ * @param cmd           Command block
+ * @param cmd_size      Command block size in bytes
+ * @param ddir          Direction in which data will be transferred
+ * @param dbuf          Data send/receive buffer
+ * @param dbuf_size     Size of the data buffer
+ * @param xferred_size  Number of bytes actually transferred
+ * @param cmd           SCSI command
+ *
  * @return              Error code
  */
+static int usb_massstor_cmd(usbmast_fun_t *mfun, uint32_t tag, const void *cmd,
+    size_t cmd_size, usb_direction_t ddir, void *dbuf, size_t dbuf_size,
+    size_t *xferred_size)
+int usb_massstor_cmd(usbmast_fun_t *mfun, uint32_t tag, scsi_cmd_t *cmd)
+{
         int rc;
+        int retval = EOK;
         size_t act_size;
         usb_pipe_t *bulk_in_pipe = mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe;
         usb_pipe_t *bulk_out_pipe = mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe;
+        usb_direction_t ddir;
+        void *dbuf;
+        size_t dbuf_size;
+        if (cmd->data_out != NULL && cmd->data_in == NULL) {
+                ddir = USB_DIRECTION_OUT;
+                dbuf = (void *)cmd->data_out;
+                dbuf_size = cmd->data_out_size;
+        } else if (cmd->data_out == NULL && cmd->data_in != NULL) {
+                ddir = USB_DIRECTION_IN;
+                dbuf = cmd->data_in;
+                dbuf_size = cmd->data_in_size;
+        } else {
+                assert(false);
+        }
         /* Prepare CBW - command block wrapper */
         usb_massstor_cbw_t cbw;
         usb_massstor_cbw_prepare(&cbw, tag, dbuf_size, ddir, mfun->lun,
             cmd_size, cmd);
+            cmd->cdb_size, cmd->cdb);
         /* Send the CBW. */
+        MASTLOG("Sending CBW.\n");
         rc = usb_pipe_write(bulk_out_pipe, &cbw, sizeof(cbw));
         MASTLOG("CBW '%s' sent: %s.\n",
             usb_debug_str_buffer((uint8_t *) &cbw, sizeof(cbw), 0),
             str_error(rc));
         if (rc != EOK) {
                 return rc;
+        }
+        if (rc != EOK)
+                return EIO;
+        MASTLOG("Transferring data.\n");
         if (ddir == USB_DIRECTION_IN) {
                 /* Recieve data from the device. */
 …
+        }
+        if (rc != EOK) {
+                /*
+                 * XXX If the pipe is stalled, we should clear it
+                 * and read CSW.
+                 */
+                return rc;
+        if (rc == ESTALL) {
+                /* Clear stall condition and continue below to read CSW. */
+                if (ddir == USB_DIRECTION_IN) {
+                        usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
+                            mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe);
+                } else {
+                        usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
+                            mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
+                }
+        } else if (rc != EOK) {
+                return EIO;
+        }
 …
         usb_massstor_csw_t csw;
         size_t csw_size;
+        MASTLOG("Reading CSW.\n");
         rc = usb_pipe_read(bulk_in_pipe, &csw, sizeof(csw), &csw_size);
         MASTLOG("CSW '%s' received (%zu bytes): %s.\n",
 …
         if (rc != EOK) {
                 MASTLOG("rc != EOK\n");
                 return rc;
+                return EIO;
+        }
         if (csw_size != sizeof(csw)) {
                 MASTLOG("csw_size != sizeof(csw)\n");
                 return ERANGE;
+                return EIO;
+        }
         if (csw.dCSWTag != tag) {
                 MASTLOG("csw.dCSWTag != tag\n");
                 return EBADCHECKSUM;
+                return EIO;
+        }
 …
          * Determine the actual return value from the CSW.
          */
+        if (csw.dCSWStatus != 0) {
+                MASTLOG("csw.dCSWStatus != 0\n");
+                // FIXME: better error code
+                // FIXME: distinguish 0x01 and 0x02
+                return EXDEV;
+        switch (csw.dCSWStatus) {
+        case cbs_passed:
+                cmd->status = CMDS_GOOD;
+                break;
+        case cbs_failed:
+                MASTLOG("Command failed\n");
+                cmd->status = CMDS_FAILED;
+                break;
+        case cbs_phase_error:
+                MASTLOG("Phase error\n");
+                retval = EIO;
+                break;
+        default:
+                retval = EIO;
+                break;
+        }
 …
         if (residue > dbuf_size) {
                 MASTLOG("residue > dbuf_size\n");
                 return ERANGE;
+                return EIO;
+        }
 …
          */
+        if (xferred_size != NULL)
+                *xferred_size = dbuf_size - residue;
+        return EOK;
+}
+/** Perform data-in command.
+ *
+ * @param mfun          Mass storage function
+ * @param tag           Command block wrapper tag (automatically compared with
+ *                      answer)
+ * @param cmd           CDB (Command Descriptor)
+ * @param cmd_size      CDB length in bytes
+ * @param dbuf          Data receive buffer
+ * @param dbuf_size     Data receive buffer size in bytes
+ * @param proc_size     Number of bytes actually processed by device
+ *
+ * @return Error code
+ */
+int usb_massstor_data_in(usbmast_fun_t *mfun, uint32_t tag, const void *cmd,
+    size_t cmd_size, void *dbuf, size_t dbuf_size, size_t *proc_size)
+{
+        return usb_massstor_cmd(mfun, tag, cmd, cmd_size, USB_DIRECTION_IN,
+            dbuf, dbuf_size, proc_size);
+}
+/** Perform data-out command.
+ *
+ * @param mfun          Mass storage function
+ * @param tag           Command block wrapper tag (automatically compared with
+ *                      answer)
+ * @param cmd           CDB (Command Descriptor)
+ * @param cmd_size      CDB length in bytes
+ * @param data          Command data
+ * @param data_size     Size of @a data in bytes
+ * @param proc_size     Number of bytes actually processed by device
+ *
+ * @return Error code
+ */
+int usb_massstor_data_out(usbmast_fun_t *mfun, uint32_t tag, const void *cmd,
+    size_t cmd_size, const void *data, size_t data_size, size_t *proc_size)
+{
+        return usb_massstor_cmd(mfun, tag, cmd, cmd_size, USB_DIRECTION_OUT,
+            (void *) data, data_size, proc_size);
+        if (ddir == USB_DIRECTION_IN)
+                cmd->rcvd_size = dbuf_size - residue;
+        return retval;
+}

uspace/drv/bus/usb/usbmast/bo_trans.h

-              refcebe1
+              r3fb0fec
 #define BULK_OUT_EP 1
+extern int usb_massstor_data_in(usbmast_fun_t *, uint32_t, const void *,
+    size_t, void *, size_t, size_t *);
+extern int usb_massstor_data_out(usbmast_fun_t *, uint32_t, const void *,
+    size_t, const void *, size_t, size_t *);
+typedef enum cmd_status {
+        CMDS_GOOD,
+        CMDS_FAILED
+} cmd_status_t;
+/** SCSI command.
+ *
+ * Contains (a subset of) the input and output arguments of SCSI
+ * Execute Command procedure call (see SAM-4 chapter 5.1)
+ */
+typedef struct {
+        /*
+         * Related to IN fields
+         */
+        /** Command Descriptor Block */
+        void *cdb;
+        /** CDB size in bytes */
+        size_t cdb_size;
+        /** Outgoing data */
+        const void *data_out;
+        /** Size of outgoing data in bytes */
+        size_t data_out_size;
+        /*
+         * Related to OUT fields
+         */
+        /** Buffer for incoming data */
+        void *data_in;
+        /** Size of input buffer in bytes */
+        size_t data_in_size;
+        /** Number of bytes actually received */
+        size_t rcvd_size;
+        /** Status */
+        cmd_status_t status;
+} scsi_cmd_t;
+extern int usb_massstor_cmd(usbmast_fun_t *, uint32_t, scsi_cmd_t *);
 extern int usb_massstor_reset(usbmast_dev_t *);
 extern void usb_massstor_reset_recovery(usbmast_dev_t *);

uspace/drv/bus/usb/usbmast/cmdw.h

-              refcebe1
+              r3fb0fec
 } __attribute__((packed)) usb_massstor_csw_t;
+enum cmd_block_status {
+        cbs_passed      = 0x00,
+        cbs_failed      = 0x01,
+        cbs_phase_error = 0x02
+};
 extern void usb_massstor_cbw_prepare(usb_massstor_cbw_t *, uint32_t, uint32_t,
     usb_direction_t, uint8_t, uint8_t, const uint8_t *);

uspace/drv/bus/usb/usbmast/scsi_ms.c

-              refcebe1
+              r3fb0fec
+}
+static void usbmast_dump_sense(scsi_sense_data_t *sense_buf)
+{
+        unsigned sense_key;
+        sense_key = sense_buf->flags_key & 0x0f;
+        printf("Got sense data. Sense key: 0x%x (%s), ASC 0x%02x, "
+            "ASCQ 0x%02x.\n", sense_key,
+            scsi_get_sense_key_str(sense_key),
+            sense_buf->additional_code,
+            sense_buf->additional_cqual);
+}
+/** Run SCSI command.
+ *
+ * Run command and repeat in case of unit attention.
+ * XXX This is too simplified.
+ */
+static int usbmast_run_cmd(usbmast_fun_t *mfun, scsi_cmd_t *cmd)
+{
+        uint8_t sense_key;
+        scsi_sense_data_t sense_buf;
+        int rc;
+        do {
+                rc = usb_massstor_cmd(mfun, 0xDEADBEEF, cmd);
+                if (rc != EOK) {
+                        usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                           mfun->mdev->ddf_dev->name, str_error(rc));
+                        return rc;
+                }
+                if (cmd->status == CMDS_GOOD)
+                        return EOK;
+                usb_log_error("SCSI command failed, device %s.\n",
+                    mfun->mdev->ddf_dev->name);
+                rc = usbmast_request_sense(mfun, &sense_buf, sizeof(sense_buf));
+                if (rc != EOK) {
+                        usb_log_error("Failed to read sense data.\n");
+                        return EIO;
+                }
+                /* Dump sense data to log */
+                usbmast_dump_sense(&sense_buf);
+                /* Get sense key */
+                sense_key = sense_buf.flags_key & 0x0f;
+                if (sense_key == SCSI_SK_UNIT_ATTENTION) {
+                        printf("Got unit attention. Re-trying command.\n");
+                }
+        } while (sense_key == SCSI_SK_UNIT_ATTENTION);
+        /* Command status is not good, nevertheless transport succeeded. */
+        return EOK;
+}
 /** Perform SCSI Inquiry command on USB mass storage device.
+ *
 …
+{
         scsi_std_inquiry_data_t inq_data;
         size_t response_len;
+        scsi_cmd_t cmd;
         scsi_cdb_inquiry_t cdb;
         int rc;
 …
         cdb.alloc_len = host2uint16_t_be(sizeof(inq_data));
+        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
+            sizeof(cdb), &inq_data, sizeof(inq_data), &response_len);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = &inq_data;
+        cmd.data_in_size = sizeof(inq_data);
+        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
         if (rc != EOK) {
+                usb_log_error("Inquiry failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (response_len < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
+                usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Inquiry command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
+                return EIO;
+        }
+        if (cmd.rcvd_size < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
                 usb_log_error("SCSI Inquiry response too short (%zu).\n",
                     response_len);
+                    cmd.rcvd_size);
                 return EIO;
+        }
 …
 int usbmast_request_sense(usbmast_fun_t *mfun, void *buf, size_t size)
+{
+        scsi_cmd_t cmd;
         scsi_cdb_request_sense_t cdb;
-        size_t data_len;
         int rc;
 …
         cdb.alloc_len = min(size, SCSI_SENSE_DATA_MAX_SIZE);
+        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
+            sizeof(cdb), buf, size, &data_len);
+        if (rc != EOK) {
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = buf;
+        cmd.data_in_size = size;
+        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
+        if (rc != EOK || cmd.status != CMDS_GOOD) {
                 usb_log_error("Request Sense failed, device %s: %s.\n",
                    mfun->mdev->ddf_dev->name, str_error(rc));
 …
+        }
         if (data_len < SCSI_SENSE_DATA_MIN_SIZE) {
+        if (cmd.rcvd_size < SCSI_SENSE_DATA_MIN_SIZE) {
                 /* The missing bytes should be considered to be zeroes. */
                 memset((uint8_t *)buf + data_len, 0,
                     SCSI_SENSE_DATA_MIN_SIZE - data_len);
+                memset((uint8_t *)buf + cmd.rcvd_size, 0,
+                    SCSI_SENSE_DATA_MIN_SIZE - cmd.rcvd_size);
+        }
 …
     uint32_t *block_size)
+{
+        scsi_cmd_t cmd;
         scsi_cdb_read_capacity_10_t cdb;
         scsi_read_capacity_10_data_t data;
-        size_t data_len;
         int rc;
 …
         cdb.op_code = SCSI_CMD_READ_CAPACITY_10;
+        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
+            sizeof(cdb), &data, sizeof(data), &data_len);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = &data;
+        cmd.data_in_size = sizeof(data);
+        rc = usbmast_run_cmd(mfun, &cmd);
         if (rc != EOK) {
+                usb_log_error("Read Capacity (10) failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (data_len < sizeof(data)) {
+                usb_log_error("Read Capacity (10) transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Read Capacity (10) command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
+                return EIO;
+        }
+        if (cmd.rcvd_size < sizeof(data)) {
                 usb_log_error("SCSI Read Capacity response too short (%zu).\n",
                     data_len);
+                    cmd.rcvd_size);
                 return EIO;
+        }
 …
 int usbmast_read(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, void *buf)
+{
+        scsi_cdb_read_12_t cdb;
+        size_t data_len;
+        int rc;
+        /* XXX Need softstate to store block size. */
+        scsi_cmd_t cmd;
+        scsi_cdb_read_10_t cdb;
+        int rc;
         if (ba > UINT32_MAX)
                 return ELIMIT;
         if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
+        if (nblocks > UINT16_MAX)
                 return ELIMIT;
         memset(&cdb, 0, sizeof(cdb));
         cdb.op_code = SCSI_CMD_READ_12;
+        cdb.op_code = SCSI_CMD_READ_10;
         cdb.lba = host2uint32_t_be(ba);
+        cdb.xfer_len = host2uint32_t_be(nblocks);
+        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
+            sizeof(cdb), buf, nblocks * mfun->block_size, &data_len);
+        cdb.xfer_len = host2uint16_t_be(nblocks);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = buf;
+        cmd.data_in_size = nblocks * mfun->block_size;
+        rc = usbmast_run_cmd(mfun, &cmd);
         if (rc != EOK) {
+                usb_log_error("Read (12) failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (data_len < nblocks * mfun->block_size) {
+                usb_log_error("Read (10) transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Read (10) command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
+                return EIO;
+        }
+        if (cmd.rcvd_size < nblocks * mfun->block_size) {
                 usb_log_error("SCSI Read response too short (%zu).\n",
                     data_len);
+                    cmd.rcvd_size);
                 return EIO;
+        }
 …
     const void *data)
+{
         scsi_cdb_write_12_t cdb;
         size_t sent_len;
+        scsi_cmd_t cmd;
+        scsi_cdb_write_10_t cdb;
         int rc;
 …
                 return ELIMIT;
         if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
+        if (nblocks > UINT16_MAX)
                 return ELIMIT;
         memset(&cdb, 0, sizeof(cdb));
         cdb.op_code = SCSI_CMD_WRITE_12;
+        cdb.op_code = SCSI_CMD_WRITE_10;
         cdb.lba = host2uint32_t_be(ba);
+        cdb.xfer_len = host2uint32_t_be(nblocks);
+        rc = usb_massstor_data_out(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
+            sizeof(cdb), data, nblocks * mfun->block_size, &sent_len);
+        cdb.xfer_len = host2uint16_t_be(nblocks);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_out = data;
+        cmd.data_out_size = nblocks * mfun->block_size;
+        rc = usbmast_run_cmd(mfun, &cmd);
         if (rc != EOK) {
                 usb_log_error("Write (12) failed, device %s: %s.\n",
                    mfun->mdev->ddf_dev->name, str_error(rc));
                 return rc;
+        }
         if (sent_len < nblocks * mfun->block_size) {
                 usb_log_error("SCSI Write not all bytes transferred (%zu).\n",
                     sent_len);
+                usb_log_error("Write (10) transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Write (10) command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
                 return EIO;
+        }

uspace/lib/c/Makefile

-              refcebe1
+              r3fb0fec
 -include arch/$(UARCH)/Makefile.inc
-EXTRA_CFLAGS += -I../../srv/loader/include
 GENERIC_SOURCES = \
         generic/libc.c \
 …
         generic/device/hw_res.c \
         generic/device/char_dev.c \
+        generic/elf/elf_load.c \
         generic/event.c \
         generic/errno.c \
 …
                 generic/dlfcn.c \
                 generic/rtld/rtld.c \
-                generic/rtld/elf_load.c \
                 generic/rtld/dynamic.c \
                 generic/rtld/module.c \

uspace/lib/c/generic/elf/elf_load.c

-              refcebe1
+              r3fb0fec
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #include <assert.h>
 #include <as.h>
+#include <elf/elf.h>
 #include <unistd.h>
 #include <fcntl.h>
 …
 #include <entry_point.h>
+#include "elf.h"
+#include "elf_load.h"
+#include <elf/elf_load.h>
 #define DPRINTF(...)
 …
 static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
-/** Read until the buffer is read in its entirety. */
-static int my_read(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));
-        return cnt;
+}
 /** Load ELF binary from a file.
+ *
 …
         int i, rc;
         rc = my_read(elf->fd, header, sizeof(elf_header_t));
         if (rc < 0) {
+        rc = read_all(elf->fd, header, sizeof(elf_header_t));
+        if (rc != sizeof(elf_header_t)) {
                 DPRINTF("Read error.\n");
                 return EE_INVALID;
 …
                         + i * sizeof(elf_segment_header_t), SEEK_SET);
                 rc = my_read(elf->fd, &segment_hdr,
+                rc = read_all(elf->fd, &segment_hdr,
                     sizeof(elf_segment_header_t));
                 if (rc < 0) {
+                if (rc != sizeof(elf_segment_header_t)) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
 …
                     + i * sizeof(elf_section_header_t), SEEK_SET);
                 rc = my_read(elf->fd, &section_hdr,
+                rc = read_all(elf->fd, &section_hdr,
                     sizeof(elf_section_header_t));
                 if (rc < 0) {
+                if (rc != sizeof(elf_section_header_t)) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
 …
         uintptr_t seg_addr;
         size_t mem_sz;
         int rc;
+        ssize_t rc;
         bias = elf->bias;
 …
                 if (now > left) now = left;
                 rc = my_read(elf->fd, dp, now);
                 if (rc < 0) {
+                rc = read_all(elf->fd, dp, now);
+                if (rc != (ssize_t) now) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;

uspace/lib/c/generic/io/io.c

-              refcebe1
+              r3fb0fec
+                }
                 buf += now;
+                data += now;
                 stream->buf_head += now;
                 buf_free -= now;
                 bytes_left -= now;
                 total_written += now;
+                stream->buf_state = _bs_write;
                 if (buf_free == 0) {
 …
+                }
+        }
-        if (total_written > 0)
-                stream->buf_state = _bs_write;
         if (need_flush)

uspace/lib/c/generic/rtld/module.c

-              refcebe1
+              r3fb0fec
  */
+#include <adt/list.h>
+#include <elf/elf_load.h>
+#include <fcntl.h>
+#include <loader/pcb.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <adt/list.h>
-#include <loader/pcb.h>
 #include <rtld/rtld.h>
 …
 #include <rtld/rtld_arch.h>
 #include <rtld/module.h>
-#include <elf_load.h>
 /** (Eagerly) process all relocation tables in a module.
 …
 module_t *module_find(const char *name)
+{
-        link_t *head = &runtime_env->modules_head;
-        link_t *cur;
         module_t *m;
         const char *p, *soname;
 …
         /* Traverse list of all modules. Not extremely fast, but simple */
+        DPRINTF("head = %p\n", head);
+        for (cur = head->next; cur != head; cur = cur->next) {
+        list_foreach(runtime_env->modules, cur) {
                 DPRINTF("cur = %p\n", cur);
                 m = list_get_instance(cur, module_t, modules_link);
 …
         /* Insert into the list of loaded modules */
         list_append(&m->modules_link, &runtime_env->modules_head);
+        list_append(&m->modules_link, &runtime_env->modules);
         return m;
 …
 void modules_process_relocs(module_t *start)
+{
+        link_t *head = &runtime_env->modules_head;
+        link_t *cur;
+        module_t *m;
+        for (cur = head->next; cur != head; cur = cur->next) {
+        module_t *m;
+        list_foreach(runtime_env->modules, cur) {
                 m = list_get_instance(cur, module_t, modules_link);
 …
 void modules_untag(void)
+{
+        link_t *head = &runtime_env->modules_head;
+        link_t *cur;
+        module_t *m;
+        for (cur = head->next; cur != head; cur = cur->next) {
+        module_t *m;
+        list_foreach(runtime_env->modules, cur) {
                 m = list_get_instance(cur, module_t, modules_link);
                 m->bfs_tag = false;

uspace/lib/c/generic/rtld/rtld.c

refcebe1	r3fb0fec
44	44	{
45	45	runtime_env = &rt_env_static;
46		list_initialize(&runtime_env->modules~~_head~~);
	46	list_initialize(&runtime_env->modules);
47	47	runtime_env->next_bias = 0x2000000;
48	48	runtime_env->program = NULL;

uspace/lib/c/generic/rtld/symbol.c

-              refcebe1
+              r3fb0fec
 #include <stdlib.h>
+#include <elf/elf.h>
 #include <rtld/rtld.h>
 #include <rtld/rtld_debug.h>
 #include <rtld/symbol.h>
-#include <elf.h>
 /*
 …
         module_t *m, *dm;
         elf_symbol_t *sym, *s;
         link_t queue_head;
+        list_t queue;
         size_t i;
 …
         /* Insert root (the program) into the queue and tag it */
         list_initialize(&queue_head);
+        list_initialize(&queue);
         start->bfs_tag = true;
         list_append(&start->queue_link, &queue_head);
+        list_append(&start->queue_link, &queue);
         /* If the symbol is found, it will be stored in 'sym' */
 …
         /* While queue is not empty */
         while (!list_empty(&queue_head)) {
+        while (!list_empty(&queue)) {
                 /* Pop first element from the queue */
                 m = list_get_instance(queue_head.next, module_t, queue_link);
+                m = list_get_instance(list_first(&queue), module_t, queue_link);
                 list_remove(&m->queue_link);
 …
                         if (dm->bfs_tag == false) {
                                 dm->bfs_tag = true;
                                 list_append(&dm->queue_link, &queue_head);
+                                list_append(&dm->queue_link, &queue);
+                        }
+                }
 …
         /* Empty the queue so that we leave it in a clean state */
         while (!list_empty(&queue_head))
                 list_remove(queue_head.next);
+        while (!list_empty(&queue))
+                list_remove(list_first(&queue));
         if (!sym) {

uspace/lib/c/generic/vfs/vfs.c

-              refcebe1
+              r3fb0fec
+}
+/** Read entire buffer.
+ *
+ * In face of short reads this function continues reading until either
+ * the entire buffer is read or no more data is available (at end of file).
+ *
+ * @param fildes        File descriptor
+ * @param buf           Buffer, @a nbytes bytes long
+ * @param nbytes        Number of bytes to read
+ *
+ * @return              On success, positive number of bytes read.
+ *                      On failure, negative error code from read().
+ */
+ssize_t read_all(int fildes, void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        size_t nread = 0;
+        uint8_t *bp = (uint8_t *) buf;
+        do {
+                bp += cnt;
+                nread += cnt;
+                cnt = read(fildes, bp, nbyte - nread);
+        } while (cnt > 0 && (nbyte - nread - cnt) > 0);
+        if (cnt < 0)
+                return cnt;
+        return nread + cnt;
+}
+/** Write entire buffer.
+ *
+ * This function fails if it cannot write exactly @a len bytes to the file.
+ *
+ * @param fildes        File descriptor
+ * @param buf           Data, @a nbytes bytes long
+ * @param nbytes        Number of bytes to write
+ *
+ * @return              EOK on error, return value from write() if writing
+ *                      failed.
+ */
+ssize_t write_all(int fildes, const void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        ssize_t nwritten = 0;
+        const uint8_t *bp = (uint8_t *) buf;
+        do {
+                bp += cnt;
+                nwritten += cnt;
+                cnt = write(fildes, bp, nbyte - nwritten);
+        } while (cnt > 0 && ((ssize_t )nbyte - nwritten - cnt) > 0);
+        if (cnt < 0)
+                return cnt;
+        if ((ssize_t)nbyte - nwritten - cnt > 0)
+                return EIO;
+        return nbyte;
+}
 int fsync(int fildes)
+{

uspace/lib/c/include/elf/elf_load.h

-              refcebe1
+              r3fb0fec
 /*
+ * Copyright (c) 2006 Sergey Bondari
  * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
 …
 #include <arch/elf.h>
+#include <elf/elf.h>
 #include <sys/types.h>
 #include <loader/pcb.h>
+#include "elf.h"
+/**
+ * ELF error return codes
+ */
+#define EE_OK                   0       /* No error */
+#define EE_INVALID              1       /* Invalid ELF image */
+#define EE_MEMORY               2       /* Cannot allocate address space */
+#define EE_INCOMPATIBLE         3       /* ELF image is not compatible with current architecture */
+#define EE_UNSUPPORTED          4       /* Non-supported ELF (e.g. dynamic ELFs) */
+#define EE_LOADER               5       /* The image is actually a program loader. */
+#define EE_IRRECOVERABLE        6
 typedef enum {
 …
 } elf_ld_t;
+int elf_load_file(const char *file_name, size_t so_bias, eld_flags_t flags,
     elf_info_t *info);
 void elf_create_pcb(elf_info_t *info, pcb_t *pcb);
+extern const char *elf_error(unsigned int);
+extern int elf_load_file(const char *, size_t, eld_flags_t, elf_info_t *);
+extern void elf_create_pcb(elf_info_t *, pcb_t *);
 #endif

uspace/lib/c/include/rtld/elf_dyn.h

refcebe1	r3fb0fec
39	39	#include <sys/types.h>
40	40
41		#include <elf.h>
	41	#include <elf/elf.h>
42	42	#include <libarch/rtld/elf_dyn.h>
43	43

uspace/lib/c/include/rtld/rtld.h

refcebe1	r3fb0fec
49	49
50	50	/** List of all loaded modules including rtld and the program */
51		li~~nk_t modules_head~~;
	51	list_t modules;
52	52
53	53	/** Temporary hack to place each module at different address. */

uspace/lib/c/include/rtld/symbol.h

-              refcebe1
+              r3fb0fec
 #define LIBC_RTLD_SYMBOL_H_
+#include <elf/elf.h>
 #include <rtld/rtld.h>
-#include <elf.h>
 elf_symbol_t *symbol_bfs_find(const char *name, module_t *start, module_t **mod);

uspace/lib/c/include/unistd.h

-              refcebe1
+              r3fb0fec
 extern ssize_t read(int, void *, size_t);
+extern ssize_t read_all(int, void *, size_t);
+extern ssize_t write_all(int, const void *, size_t);
 extern off64_t lseek(int, off64_t, int);
 extern int ftruncate(int, aoff64_t);

uspace/lib/scsi/include/scsi/sbc.h

-              refcebe1
+              r3fb0fec
 };
+/** SCSI Read (10) command */
+typedef struct {
+        /** Operation code (SCSI_CMD_READ_10) */
+        uint8_t op_code;
+        /** RdProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
+        uint8_t flags;
+        /** Logical block address */
+        uint32_t lba;
+        /** Reserved, Group Number */
+        uint8_t group_no;
+        /** Transfer length */
+        uint16_t xfer_len;
+        /** Control */
+        uint8_t control;
+} __attribute__((packed)) scsi_cdb_read_10_t;
 /** SCSI Read (12) command */
 typedef struct {
         /** Operation code (SCSI_CMD_READ_12) */
         uint8_t op_code;
         /** RdProtect, DPO, FUA, Reserved, FUA_NV, Reserved */
+        /** RdProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
         uint8_t flags;
         /** Logical block address */
 …
 } scsi_read_capacity_10_data_t;
+/** SCSI Write (10) command */
+typedef struct {
+        /** Operation code (SCSI_CMD_WRITE_10) */
+        uint8_t op_code;
+        /** WrProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
+        uint8_t flags;
+        /** Logical block address */
+        uint32_t lba;
+        /** Reserved, Group Number */
+        uint8_t group_no;
+        /** Transfer length */
+        uint16_t xfer_len;
+        /** Control */
+        uint8_t control;
+} __attribute__((packed)) scsi_cdb_write_10_t;
 /** SCSI Write (12) command */
 typedef struct {
         /** Operation code (SCSI_CMD_WRITE_12) */
         uint8_t op_code;
         /** WrProtect, DPO, FUA, Reserved, FUA_NV, Reserved */
+        /** WrProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
         uint8_t flags;
         /** Logical block address */

uspace/lib/scsi/include/scsi/spc.h

-              refcebe1
+              r3fb0fec
         uint8_t additional_len;
         /** Command-specific Information */
         uint8_t cmd_spec;
+        uint32_t cmd_spec;
         /** Additional Sense Code */
         uint8_t additional_code;
 …
         SCSI_SK_ABORTED_COMMAND = 0xb,
         SCSI_SK_VOLUME_OVERFLOW = 0xd,
+        SCSI_SK_MISCOMPARE      = 0xe
+        SCSI_SK_MISCOMPARE      = 0xe,
+        SCSI_SK_LIMIT           = 0x10
 };
 extern const char *scsi_dev_type_str[SCSI_DEV_LIMIT];
+extern const char *scsi_sense_key_str[SCSI_SK_LIMIT];
 extern const char *scsi_get_dev_type_str(unsigned);
+extern const char *scsi_get_sense_key_str(unsigned);
 #endif

uspace/lib/scsi/src/spc.c

-              refcebe1
+              r3fb0fec
 };
+const char *scsi_sense_key_str[SCSI_SK_LIMIT] = {
+        [SCSI_SK_NO_SENSE]              = "No Sense",
+        [SCSI_SK_RECOVERED_ERROR]       = "Recovered Error",
+        [SCSI_SK_NOT_READY]             = "Not Ready",
+        [SCSI_SK_MEDIUM_ERROR]          = "Medium Error",
+        [SCSI_SK_HARDWARE_ERROR]        = "Hardware Error",
+        [SCSI_SK_ILLEGAL_REQUEST]       = "Illegal Request",
+        [SCSI_SK_UNIT_ATTENTION]        = "Unit Attention",
+        [SCSI_SK_DATA_PROTECT]          = "Data Protect",
+        [SCSI_SK_BLANK_CHECK]           = "Blank Check",
+        [SCSI_SK_VENDOR_SPECIFIC]       = "Vendor-specific",
+        [SCSI_SK_COPY_ABORTED]          = "Copy Aborted",
+        [SCSI_SK_ABORTED_COMMAND]       = "Aborted Command",
+        [SCSI_SK_VOLUME_OVERFLOW]       = "Volume Overflow",
+        [SCSI_SK_MISCOMPARE]            = "Miscompare"
+};
 /** Get peripheral device type string.
+ *
 …
+{
         if (dev_type >= SCSI_DEV_LIMIT || scsi_dev_type_str[dev_type] == NULL)
                 return "<unknown>";
+                return "Unknown";
         return scsi_dev_type_str[dev_type];
+}
+/** Get sense key string.
+ *
+ * Return string description of SCSI sense key.
+ * The returned string is valid indefinitely, the caller should
+ * not attempt to free it.
+ */
+const char *scsi_get_sense_key_str(unsigned sense_key)
+{
+        if (sense_key >= SCSI_SK_LIMIT || scsi_sense_key_str[sense_key] == NULL)
+                return "Unknown";
+        return scsi_sense_key_str[sense_key];
+}

uspace/srv/devman/devman.c

-              refcebe1
+              r3fb0fec
+        }
         ssize_t read_bytes = safe_read(fd, buf, len);
+        ssize_t read_bytes = read_all(fd, buf, len);
         if (read_bytes <= 0) {
+                log_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
+                log_msg(LVL_ERROR, "Unable to read file '%s' (%zd).", conf_path,
+                    read_bytes);
                 goto cleanup;
+        }
 …
+        }
         insert_fun_node(tree, fun, clone_string(""), NULL);
+        insert_fun_node(tree, fun, str_dup(""), NULL);
         match_id_t *id = create_match_id();
         id->id = clone_string("root");
+        id->id = str_dup("root");
         id->score = 100;
         add_match_id(&fun->match_ids, id);

uspace/srv/devman/util.c

-              refcebe1
+              r3fb0fec
+}
-char *clone_string(const char *s)
+{
-        size_t size = str_size(s) + 1;
-        char *str;
-        str = (char *) malloc(size);
-        if (str != NULL)
-                str_cpy(str, size, s);
-        return str;
+}
 void replace_char(char *str, char orig, char repl)
+{
 …
+}
-ssize_t safe_read(int fd, void *buffer, size_t size)
+{
-        if (size == 0) {
-                return 0;
+        }
-        uint8_t *buf_ptr = (uint8_t *) buffer;
-        size_t total_read = 0;
-        while (total_read < size) {
-                ssize_t bytes_read = read(fd, buf_ptr, size - total_read);
-                if (bytes_read < 0) {
-                        /* Error. */
-                        return bytes_read;
-                } else if (bytes_read == 0) {
-                        /* Possibly end of file. */
-                        break;
-                } else {
-                        /* Read at least something. */
-                        buf_ptr += bytes_read;
-                        total_read += bytes_read;
+                }
+        }
-        return (ssize_t) total_read;
+}
 /** @}
  */

uspace/srv/devman/util.h

-              refcebe1
+              r3fb0fec
 extern size_t get_nonspace_len(const char *);
 extern void free_not_null(const void *);
-extern char *clone_string(const char *);
 extern void replace_char(char *, char, char);
-extern ssize_t safe_read(int, void *, size_t);
 #endif

uspace/srv/loader/Makefile

-              refcebe1
+              r3fb0fec
 LINKER_SCRIPT = $(LIBC_PREFIX)/arch/$(UARCH)/_link-loader.ld
-EXTRA_CFLAGS = -Iinclude
 BINARY = loader
 STATIC_ONLY = y
 …
 GENERIC_SOURCES = \
         main.c \
-        elf_load.c \
         interp.s

uspace/srv/loader/main.c

-              refcebe1
+              r3fb0fec
 #include <str.h>
 #include <as.h>
 #include <elf.h>
 #include <elf_load.h>
+#include <elf/elf.h>
+#include <elf/elf_load.h>
 #ifdef CONFIG_RTLD
 …
         /* Initialize list of loaded modules */
         list_initialize(&runtime_env->modules_head);
         list_append(&prog_mod.modules_link, &runtime_env->modules_head);
+        list_initialize(&runtime_env->modules);
+        list_append(&prog_mod.modules_link, &runtime_env->modules);
         /* Pointer to program module. Used as root of the module graph. */

Context Navigation

Changeset 3fb0fec in mainline

Legend:

Download in other formats: