Changeset 701 for trunk/softs/tsar_boot/src/reset_utils.c

Timestamp:

May 25, 2014, 5:35:37 PM (10 years ago)

Author:

cfuguet

Message:

tsar_boot:

• Important optimization in the reset_elf_loader function.

• Implementation of pread function which uses bytes addressing to read disk.

• pread function alternates between direct tranfer from disk to memory and from disk to a memory cache block based on alignment of byte address, i.e., when file offset is aligned to disk block (512 bytes), pread uses DMA capacity of disk to transfer directly to memory, otherwise it passes before by a memory cache block and then performs a memcpy to transfer data to final destination.

• the cache block used by pread function, allows to treat succeeding reads on the same block without accessing the disk.

File:

• trunk/softs/tsar_boot/src/reset_utils.c (modified) (10 diffs)

trunk/softs/tsar_boot/src/reset_utils.c

@@ -9 +9 @@
 #include <reset_utils.h>
 
+/*
+ * pread(size_t file_offset, void* buf, size_t nbyte, size_t offset)
+ *
+ * read from disk into buffer "nbyte" bytes from (file_offset + offset)
+ *
+ * \param file_offset: Disk relative offset of file
+ * \param buf: Destination buffer
+ * \param nbyte: Number of bytes to read
+ * \param offset: File relative offset
+ *
+ * \note Absolute disk offset (in bytes) is (file_offset + offset)
+ */
+int pread(size_t file_offset, void *buf, size_t nbyte, size_t offset) {
+    if (nbyte == 0) return 0;
+
+    /*
+     * Cache block data buffer and cached block index
+     */
+    static struct aligned_blk blk_buf;
+    static int blk_buf_idx = -1;
+
+    char *dst;
+    int offset_blk;
+    int unaligned_nbyte;
+    int read_nbyte;
+
+    dst = (char*) buf;
+
+    /*
+     * Offset parameter is relative to file, therefore compute disk relative
+     * offset (in bytes)
+     */
+    offset += file_offset;
+
+    /*
+     * Read unaligned bytes at start of segment passing by block cache
+     */
+    offset_blk = (offset / BLOCK_SIZE);
+    offset = (offset % BLOCK_SIZE);
+    unaligned_nbyte = BLOCK_SIZE - offset;
+    read_nbyte = 0;
+    if (offset) {
+        /*
+         * Check cache block hit: if miss, read new block else, use cache block
+         * data
+         */
+        if (offset_blk != blk_buf_idx) {
+            if (reset_ioc_read(offset_blk, (void*)&blk_buf, 1)) {
+                return -1; 
+            }
+        }
+        blk_buf_idx = offset_blk;
+        read_nbyte = (nbyte > unaligned_nbyte) ? unaligned_nbyte : nbyte; 
+        memcpy((void*)dst, (void*)&blk_buf.b[offset], read_nbyte);
+        nbyte -= read_nbyte;
+        offset_blk += 1;
+    }
+
+    /*
+     * Read aligned bytes directly to buffer
+     */
+    size_t nblk = nbyte / BLOCK_SIZE; 
+    if (nblk) {
+        if (reset_ioc_read(offset_blk, (void*)&dst[read_nbyte], nblk)) {
+            return -1;
+        }
+        read_nbyte += (nblk * BLOCK_SIZE);
+        nbyte -= read_nbyte;
+        offset_blk += nblk;
+    }
+
+    /*
+     * Read unaligned bytes at the end of segment passing by block cache
+     */
+    if (nbyte) {
+        if (reset_ioc_read(offset_blk, (void*)&blk_buf, 1)) {
+            return -1;
+        }
+        blk_buf_idx = offset_blk;
+        memcpy((void*)&dst[read_nbyte], (void*)&blk_buf, nbyte);
+        read_nbyte += nbyte;
+    }
+    return read_nbyte; 
+}
+
 /********************************************************************
  * proctime()
@@ -31 +116 @@
  *
  ********************************************************************/
-void * memcpy(void *_dst, const void *_src, unsigned int size)
+void* memcpy(void *_dst, const void *_src, size_t n)
 {
     unsigned int *dst = _dst;
@@ -37 +122 @@
     if ( !((unsigned int)dst & 3) && !((unsigned int)src & 3) )
     {
-        while (size > 3) 
+        while (n > 3) 
         {
             *dst++ = *src++;
-            size -= 4;
+            n -= 4;
         }
     }
@@ -46 +131 @@
     unsigned char *cdst = (unsigned char*) dst;
     unsigned char *csrc = (unsigned char*) src;
-
-    while (size--) 
+    while (n--) 
     {
         *cdst++ = *csrc++;
@@ -64 +148 @@
  *
  ********************************************************************/
-void * memset(void *_dst, const int value, unsigned int size)
-{
-    unsigned char val = (unsigned char) value;
-    int word = (val << 24) | (val << 16) | (val << 8 ) | val;
+void* memset(void *_dst, int c, size_t len)
+{
+    if (len == 0) return _dst;
+
+    unsigned char val = (unsigned char) c;
+    unsigned int word = (val << 24) | (val << 16) | (val << 8 ) | val;
 
     /*
@@ -76 +162 @@
     if ( !((unsigned int)dst & 3) )
     {
-        while (size > 3) 
+        while (len > 3) 
         {
             *dst++ = word;
-            size -= 4;
+            len -= 4;
         }
     }
@@ -87 +173 @@
      * or size is smaller than 4 
      */
-    char* cdst = (char*) _dst;
-    while(size--)
-    {
-        *cdst++ = (char) value;
+    unsigned char* cdst = (unsigned char*) _dst;
+    while(len--)
+    {
+        *cdst++ = (unsigned char) c;
     }
 
     return _dst;
+}
+
+/********************************************************************
+ * check_elf_header(Elf32_Ehdr*)
+ *
+ * Verify that ELF file is valid and that the number of program
+ * headers does not exceed the defined maximum
+ *
+ * \param ehdr : ELF header pointer
+ *
+ ********************************************************************/
+void check_elf_header(Elf32_Ehdr *ehdr)
+{
+    /*
+     * Verification of ELF Magic Number
+     */
+    if ((ehdr->e_ident[EI_MAG0] != ELFMAG0) ||
+        (ehdr->e_ident[EI_MAG1] != ELFMAG1) ||
+        (ehdr->e_ident[EI_MAG2] != ELFMAG2) ||
+        (ehdr->e_ident[EI_MAG3] != ELFMAG3))
+    {
+        reset_puts("[RESET ERROR] Unrecognized file format (not an ELF format)\n");
+        reset_exit();
+    }
+
+    /*
+     * Verification of Program Headers table size. It must be
+     * smaller than the work size allocated for the
+     * elf_pht[PHDR_ARRAY_SIZE] array
+     */
+    if (ehdr->e_phnum > PHDR_ARRAY_SIZE)
+    {
+        reset_puts("[RESET ERROR] ELF PHDR table size too large\n");
+        reset_exit();
+    }
 }
 
@@ -108 +229 @@
     reset_puts("- type   : ");
     reset_putx(elf_phdr_ptr->p_type);
-
     reset_puts("\n- offset : ");
     reset_putx(elf_phdr_ptr->p_offset);
-
     reset_puts("\n- vaddr  : ");
     reset_putx(elf_phdr_ptr->p_vaddr);
-
     reset_puts("\n- paddr  : ");
     reset_putx(elf_phdr_ptr->p_paddr);
-
     reset_puts("\n- filesz : ");
     reset_putx(elf_phdr_ptr->p_filesz);
-
     reset_puts("\n- memsz  : ");
     reset_putx(elf_phdr_ptr->p_memsz);
-
     reset_puts("\n- flags  : ");
     reset_putx(elf_phdr_ptr->p_flags);
-
     reset_puts("\n- align  : ");
     reset_putx(elf_phdr_ptr->p_align);
+    reset_puts("\n");
 }
 
@@ -139 +254 @@
  ********************************************************************/
 #if USE_IOB 
-void reset_mcc_invalidate ( const void * buffer,
-                            unsigned int size)
-{
-    unsigned int * mcc_address = (unsigned int *)MCC_PADDR_BASE;
+void reset_mcc_invalidate (const void * buffer, size_t size)
+{
+    addr_t *mcc_address = (addr_t*)MCC_PADDR_BASE;
 
     // get the hard lock assuring exclusive access to MEMC
@@ -167 +281 @@
  ********************************************************************/
 #if (CACHE_COHERENCE == 0) || USE_IOB
-void reset_buf_invalidate ( const void * buffer,
-                            unsigned int line_size,
-                            unsigned int size)
+void reset_buf_invalidate (const void * buffer, size_t line_size, size_t size)
 {
     unsigned int i;