Changeset 8f6c7785 in mainline

Timestamp:

2013-04-26T02:55:32Z (12 years ago)

Author:

Dominik Taborsky (AT DOT) <brembyseznamcz>

Branches:

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

Children:

700f89e

Parents:

d617050

Message:

logical write functional

Files:

• tools/toolchain.sh (modified) (17 diffs)
• uspace/app/hdisk/func_gpt.c (modified) (8 diffs)
• uspace/app/hdisk/func_mbr.c (modified) (3 diffs)
• uspace/app/hdisk/hdisk.c (modified) (5 diffs)
• uspace/lib/gpt/libgpt.c (modified) (8 diffs)
• uspace/lib/gpt/libgpt.h (modified) (2 diffs)
• uspace/lib/mbr/libmbr.c (modified) (23 diffs)
• uspace/lib/mbr/libmbr.h (modified) (4 diffs)

tools/toolchain.sh

@@ -56 +56 @@
 BINUTILS_RELEASE=""
 #GCC_VERSION="4.7.2"
-GCC_VERSION="4.8.0"
+GCC_VERSION="4.7.3"
+#GCC_VERSION="4.8.0"
 GDB_VERSION="7.5"
 
@@ -72 +73 @@
         HEADER="$2"
         BODY="$3"
-        
+
         FNAME="/tmp/conftest-$$"
-        
+
         echo "#include ${HEADER}" > "${FNAME}.c"
         echo >> "${FNAME}.c"
@@ -82 +83 @@
         echo "  return 0;" >> "${FNAME}.c"
         echo "}" >> "${FNAME}.c"
-        
+
         cc -c -o "${FNAME}.o" "${FNAME}.c" 2> "${FNAME}.log"
         RC="$?"
-        
+
         if [ "$RC" -ne "0" ] ; then
                 echo " ${DEPENDENCY} not found, too old or compiler error."
@@ -114 +115 @@
                 echo
                 echo "Script failed: $2"
-                
+
                 exit 1
         fi
@@ -122 +123 @@
         FILE="$1"
         SUM="$2"
-        
+
         COMPUTED="`md5sum "${FILE}" | cut -d' ' -f1`"
         if [ "${SUM}" != "${COMPUTED}" ] ; then
                 echo
                 echo "Checksum of ${FILE} does not match."
-                
+
                 exit 2
         fi
@@ -157 +158 @@
         echo "defined, /usr/local/cross will be used by default."
         echo
-        
+
         exit 3
 }
@@ -167 +168 @@
 show_countdown() {
         TM="$1"
-        
+
         if [ "${TM}" -eq 0 ] ; then
                 echo
                 return 0
         fi
-        
+
         echo -n "${TM} "
         change_title "${TM}"
         sleep 1
-        
+
         TM="`expr "${TM}" - 1`"
         show_countdown "${TM}"
@@ -212 +213 @@
         FILE="$2"
         CHECKSUM="$3"
-        
+
         if [ ! -f "${FILE}" ]; then
                 change_title "Downloading ${FILE}"
@@ -218 +219 @@
                 check_error $? "Error downloading ${FILE}."
         fi
-        
+
         check_md5 "${FILE}" "${CHECKSUM}"
 }
@@ -224 +225 @@
 source_check() {
         FILE="$1"
-        
+
         if [ ! -f "${FILE}" ]; then
                 echo
                 echo "File ${FILE} not found."
-                
+
                 exit 4
         fi
@@ -235 +236 @@
 cleanup_dir() {
         DIR="$1"
-        
+
         if [ -d "${DIR}" ]; then
                 change_title "Removing ${DIR}"
@@ -246 +247 @@
         DIR="$1"
         DESC="$2"
-        
+
         change_title "Creating ${DESC}"
         echo ">>> Creating ${DESC}"
-        
+
         mkdir -p "${DIR}"
         test -d "${DIR}"
@@ -258 +259 @@
         FILE="$1"
         DESC="$2"
-        
+
         change_title "Unpacking ${DESC}"
         echo " >>> Unpacking ${DESC}"
-        
+
         tar -xjf "${FILE}"
         check_error $? "Error unpacking ${DESC}."
@@ -270 +271 @@
         check_dependecies
         show_countdown 10
-        
+
         BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
         GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
         GDB_SOURCE="ftp://ftp.gnu.org/gnu/gdb/"
-        
+
         download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "ee0f10756c84979622b992a4a61ea3f5"
         download_fetch "${GCC_SOURCE}" "${GCC}" "cc308a0891e778cfda7a151ab8a6e762"
@@ -283 +284 @@
         PLATFORM="$1"
         TARGET="$2"
-        
+
         WORKDIR="${BASEDIR}/${PLATFORM}"
         BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
@@ -289 +290 @@
         OBJDIR="${WORKDIR}/gcc-obj"
         GDBDIR="${WORKDIR}/gdb-${GDB_VERSION}"
-        
+
         if [ -z "${CROSS_PREFIX}" ] ; then
                 CROSS_PREFIX="/usr/local/cross"
         fi
-        
+
         PREFIX="${CROSS_PREFIX}/${PLATFORM}"
-        
+
         echo ">>> Downloading tarballs"
         #source_check "${BASEDIR}/${BINUTILS}"
         source_check "${BASEDIR}/${GCC}"
         #source_check "${BASEDIR}/${GDB}"
-        
+
         echo ">>> Removing previous content"
         #cleanup_dir "${PREFIX}"
         #cleanup_dir "${WORKDIR}"
-        
+
         create_dir "${PREFIX}" "destination directory"
         create_dir "${OBJDIR}" "GCC object directory"
-        
+
         echo ">>> Unpacking tarballs"
         cd "${WORKDIR}"
         check_error $? "Change directory failed."
-        
-        unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
-        #unpack_tarball "${BASEDIR}/${GCC}" "GCC"
-        unpack_tarball "${BASEDIR}/${GDB}" "GDB"
-        
-        echo ">>> Processing binutils (${PLATFORM})"
-        cd "${BINUTILSDIR}"
+
+        #unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
+        unpack_tarball "${BASEDIR}/${GCC}" "GCC"
+        #unpack_tarball "${BASEDIR}/${GDB}" "GDB"
+
+        #echo ">>> Processing binutils (${PLATFORM})"
+        #cd "${BINUTILSDIR}"
+        #check_error $? "Change directory failed."
+
+        #change_title "binutils: configure (${PLATFORM})"
+        #CFLAGS=-Wno-error ./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --disable-nls --disable-werror
+        #check_error $? "Error configuring binutils."
+
+        #change_title "binutils: make (${PLATFORM})"
+        #make all install
+        #check_error $? "Error compiling/installing binutils."
+
+        echo ">>> Processing GCC (${PLATFORM})"
+        cd "${OBJDIR}"
         check_error $? "Change directory failed."
-        
-        change_title "binutils: configure (${PLATFORM})"
-        CFLAGS=-Wno-error ./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --disable-nls --disable-werror
-        check_error $? "Error configuring binutils."
-        
-        change_title "binutils: make (${PLATFORM})"
-        make all install
-        check_error $? "Error compiling/installing binutils."
-        
-        echo ">>> Processing GCC (${PLATFORM})"
-        #cd "${OBJDIR}"
+
+        change_title "GCC: configure (${PLATFORM})"
+        "${GCCDIR}/configure" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c,objc,c++,obj-c++ --disable-multilib --disable-libgcj --without-headers --disable-shared --enable-lto --disable-werror
+        check_error $? "Error configuring GCC."
+
+        change_title "GCC: make (${PLATFORM})"
+        PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
+        check_error $? "Error compiling/installing GCC."
+
+        #echo ">>> Processing GDB (${PLATFORM})"
+        #cd "${GDBDIR}"
         #check_error $? "Change directory failed."
-        
-        change_title "GCC: configure (${PLATFORM})"
-        #"${GCCDIR}/configure" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c,objc,c++,obj-c++ --disable-multilib --disable-libgcj --without-headers --disable-shared --enable-lto --disable-werror
-        #check_error $? "Error configuring GCC."
-        
-        change_title "GCC: make (${PLATFORM})"
-        #PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
-        #check_error $? "Error compiling/installing GCC."
-        
-        echo ">>> Processing GDB (${PLATFORM})"
-        cd "${GDBDIR}"
-        check_error $? "Change directory failed."
-        
-        change_title "GDB: configure (${PLATFORM})"
-        ./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-"
-        check_error $? "Error configuring GDB."
-        
-        change_title "GDB: make (${PLATFORM})"
-        make all install
-        check_error $? "Error compiling/installing GDB."
-        
+
+        #change_title "GDB: configure (${PLATFORM})"
+        #./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-"
+        #check_error $? "Error configuring GDB."
+
+        #change_title "GDB: make (${PLATFORM})"
+        #make all install
+        #check_error $? "Error compiling/installing GDB."
+
         cd "${BASEDIR}"
         check_error $? "Change directory failed."
-        
+
         echo ">>> Cleaning up"
         cleanup_dir "${WORKDIR}"
-        
+
         echo
         echo ">>> Cross-compiler for ${TARGET} installed."
@@ -439 +440 @@
                 build_target "arm32" "arm-linux-gnueabi" &
                 wait
-                
+
                 build_target "ia32" "i686-pc-linux-gnu" &
                 build_target "ia64" "ia64-pc-linux-gnu" &
                 wait
-                
+
                 build_target "mips32" "mipsel-linux-gnu" &
                 build_target "mips32eb" "mips-linux-gnu" &
                 wait
-                
+
                 build_target "mips64" "mips64el-linux-gnu" &
                 build_target "ppc32" "ppc-linux-gnu" &
                 wait
-                
+
                 build_target "ppc64" "ppc64-linux-gnu" &
                 build_target "sparc64" "sparc64-linux-gnu" &

uspace/app/hdisk/func_gpt.c

@@ -49 +49 @@
                 return ENOMEM;
         }
-        
+
         return set_gpt_partition(in, p);
 }
@@ -59 +59 @@
         printf("Number of the partition to delete (counted from 0): ");
         idx = get_input_size_t(in);
-        
+
         if (gpt_remove_partition(data->gpt.parts, idx) == -1) {
                 printf("Warning: running low on memory, not resizing...\n");
         }
-        
+
         return EOK;
 }
@@ -69 +69 @@
 int print_gpt_parts(union table_data * data)
 {
+        //int rc;
         printf("Current partition scheme (GPT):\n");
         printf("\t\tStart:\tEnd:\tLength:\tType:\tName:\n");
         
-        gpt_foreach(data->gpt.parts, i, iter) {
-                printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
-                                iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
+        size_t i = 0;
+        
+        gpt_part_foreach(data->gpt.parts, iter) {
+                //printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
+                //              iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
+                printf("%3u\t%10llu %10llu %10llu %3d %s\n", i, gpt_get_start_lba(iter), gpt_get_end_lba(iter),
+                                gpt_get_end_lba(iter) - gpt_get_start_lba(iter), gpt_get_part_type(iter),
+                                gpt_get_part_name(iter));
+                i++;
         }
-        
-        return rc;
+
+        //return rc;
+        return EOK;
 }
 
@@ -83 +91 @@
 {
         int rc;
-        
+
         rc = gpt_write_partitions(data->gpt.parts, data->gpt.gpt, dev_handle);
         if (rc != EOK) {
@@ -89 +97 @@
                 return rc;
         }
-        
+
         rc = gpt_write_gpt_header(data->gpt.gpt, dev_handle);
         if (rc != EOK) {
@@ -95 +103 @@
                 return rc;
         }
-        
+
         return EOK;
 }
@@ -106 +114 @@
 static int set_gpt_partition(tinput_t * in, gpt_part_t * p)
 {
-        int rc;
-        
+        //int rc;
+
         uint64_t sa, ea;
-        
+
         printf("Set starting address (number): ");
         sa = get_input_uint64(in);
@@ -115 +123 @@
         printf("Set end addres (number): ");
         ea = get_input_uint64(in);
-        
+
         if (ea <= sa) {
                 printf("Invalid value.\n");
                 return EINVAL;
         }
-        
-        
-        p->start_addr = sa;
-        p->length = ea - sa;
-        
+
+
+        //p->start_addr = sa;
+        gpt_set_start_lba(p, sa);
+        //p->length = ea - sa;
+        gpt_set_end_lba(p, ea);
+
         return EOK;
 }

uspace/app/hdisk/func_mbr.c

@@ -83 +83 @@
 
         printf("Current partition scheme:\n");
-        printf("\t\tBootable:\tStart:\tEnd:\tLength:\tType:\n");
-
+        //printf("\t\tBootable:\tStart:\tEnd:\tLength:\tType:\n");
+        printf("\t\t%10s  %10s %10s %10s %7s\n", "Bootable:", "Start:", "End:", "Length:", "Type:");
+        
+        mbr_part_t * it;
         mbr_part_foreach(data->mbr.parts, it) {
                 if (it->type == PT_UNUSED)
                         continue;
 
-                printf("\t P%d:\t", num);
+                printf("\tP%d:\t", num);
                 if (mbr_get_flag(it, ST_BOOT))
                         printf("*");
@@ -95 +97 @@
                         printf(" ");
 
-                printf("\t%10u %10u %10u %3d\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
+                printf("\t%10u %10u %10u %7x\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
 
                 ++num;
@@ -101 +103 @@
 
         printf("%d partitions found.\n", num);
+        printf("DEBUG: primary: %hhu, logical: %u\n", data->mbr.parts->n_primary, data->mbr.parts->n_logical);
         
         return EOK;

uspace/app/hdisk/hdisk.c

@@ -73 +73 @@
                 return -1;
         }
-        
+
         init_table();
-        
+
         mbr_t * mbr = mbr_read_mbr(dev_handle);
         if(mbr == NULL) {
@@ -98 +98 @@
                 mbr_free_mbr(mbr);
                 gpt_t * gpt = gpt_read_gpt_header(dev_handle);
+                printf("here3\n");
                 if(gpt == NULL) {
                         printf("Failed to read and parse GPT header. Exiting.\n");
@@ -103 +104 @@
                 }
                 set_table_gpt(gpt);
+                printf("here4\n");
                 gpt_partitions_t * parts = gpt_read_partitions(gpt);
+                printf("here5\n");
                 if(parts == NULL) {
                         printf("Failed to read and parse partitions.\n" \
@@ -114 +117 @@
 
         rc = interact(dev_handle);
-
+        
         free_table();
-
+        
         return rc;
 }
@@ -188 +191 @@
                 input = getchar();
                 printf("%c\n", input);
-                
+
 
                 //rc = tinput_read(in, &str);

uspace/lib/gpt/libgpt.c

@@ -67 +67 @@
         int rc;
         size_t b_size;
-
+        
+        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
+        if (rc != EOK)
+                return NULL;
+        
         rc = block_get_bsize(dev_handle, &b_size);
         if (rc != EOK) {
@@ -73 +77 @@
                 return NULL;
         }
-
+        
         gpt_t * gpt = malloc(sizeof(gpt_t));
         if (gpt == NULL) {
@@ -80 +84 @@
         }
 
-        gpt->raw_data = malloc(b_size);// We might need only sizeof(gpt_header_t),
+        gpt->raw_data = malloc(b_size); // We might need only sizeof(gpt_header_t),
         if (gpt == NULL) {                              // but we should follow specs and have
                 free(gpt);                                      // zeroes through all the rest of the block
@@ -86 +90 @@
                 return NULL;
         }
-
-
+        
+        
         rc = load_and_check_header(dev_handle, GPT_HDR_BA, b_size, gpt->raw_data);
         if (rc == EBADCHECKSUM || rc == EINVAL) {
@@ -103 +107 @@
                 }
         }
-
+        
         gpt->device = dev_handle;
-
+        block_fini(dev_handle);
         return gpt;
-
+        
 fail:
+        block_fini(dev_handle);
         gpt_free_gpt(gpt);
         return NULL;
@@ -130 +135 @@
                                         uint32_t_le2host(gpt->raw_data->header_size));
 
+        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
+        if (rc != EOK)
+                return rc;
+
         rc = block_get_bsize(dev_handle, &b_size);
-        if (rc != EOK)
-                return rc;
-
-        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
         if (rc != EOK)
                 return rc;
@@ -252 +257 @@
         gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->fill * gpt->raw_data->entry_size);
 
+        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
+        if (rc != EOK)
+                return rc;
+
         rc = block_get_bsize(dev_handle, &b_size);
-        if (rc != EOK)
-                return rc;
-
-        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
         if (rc != EOK)
                 return rc;
@@ -473 +478 @@
         int rc;
 
-        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
-        if (rc != EOK)
-                return rc;
-
         rc = block_read_direct(dev_handle, addr, GPT_HDR_BS, header);
-        block_fini(dev_handle);
-        if (rc != EOK)
-                return rc;
-
+        if (rc != EOK)
+                return rc;
 
         unsigned int i;

uspace/lib/gpt/libgpt.h

@@ -153 +153 @@
 extern void                                     gpt_set_start_lba       (gpt_part_t * p, uint64_t start);
 extern uint64_t                         gpt_get_start_lba       (gpt_part_t * p);
-extern void                                     gpt_set_end_lba         (gpt_part_t * p, uint64_t start);
+extern void                                     gpt_set_end_lba         (gpt_part_t * p, uint64_t end);
 extern uint64_t                         gpt_get_end_lba         (gpt_part_t * p);
 extern unsigned char *          gpt_get_part_name       (gpt_part_t * p);
@@ -162 +162 @@
 
 
-#define gpt_foreach(parts, i, iterator) \
-                for(size_t i = 0, gpt_part_t * iterator = parts->part_array; \
-                    i < parts->fill; i++, iterator++)
+#define gpt_part_foreach(parts, iterator) \
+                for(gpt_part_t * iterator = (parts)->part_array; \
+                    iterator < (parts)->part_array + (parts)->fill; ++iterator)
 
 extern void gpt_free_gpt(gpt_t * gpt);

uspace/lib/mbr/libmbr.c

@@ -33 +33 @@
  */
 
+#include <async.h>
+#include <assert.h>
+#include <block.h>
+#include <byteorder.h>
+#include <errno.h>
 #include <ipc/bd.h>
-#include <async.h>
+#include <mem.h>
 #include <stdio.h>
-#include <block.h>
-#include <errno.h>
 #include <stdlib.h>
-#include <assert.h>
-#include <byteorder.h>
 
 #include "libmbr.h"
@@ -47 +48 @@
 static int decode_part(pt_entry_t * src, mbr_part_t * trgt, uint32_t base);
 static int decode_logical(mbr_t * mbr, mbr_partitions_t * p, mbr_part_t * ext);
-static void encode_part(mbr_part_t * src, pt_entry_t * trgt, uint32_t base);
+static void encode_part(mbr_part_t * src, pt_entry_t * trgt, uint32_t base, bool ebr);
 static int check_overlap(mbr_part_t * p1, mbr_part_t * p2);
 static int check_encaps(mbr_part_t * inner, mbr_part_t * outer);
 static int check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee);
+
+static void debug_print(unsigned char * data, size_t bytes);
 
 /** Read MBR from specific device
@@ -128 +131 @@
 mbr_partitions_t * mbr_read_partitions(mbr_t * mbr)
 {
-        int rc, i;
+        int rc, i, rc_ext;
         mbr_part_t * p;
         mbr_part_t * ext = NULL;
         mbr_partitions_t * parts;
-
+        
         if (mbr == NULL)
                 return NULL;
-
+        
         parts = mbr_alloc_partitions();
         if (parts == NULL) {
@@ -145 +148 @@
                 if (mbr->raw_data.pte[i].ptype == PT_UNUSED)
                         continue;
-
-                p = malloc(sizeof(mbr_part_t));
+                
+                //p = malloc(sizeof(mbr_part_t));
+                p = mbr_alloc_partition();
                 if (p == NULL) {
                         printf(LIBMBR_NAME ": Error on memory allocation.\n");
-                        free(p);
                         mbr_free_partitions(parts);
                         return NULL;
                 }
                 //list_append(&(p->link), &(parts->list));
-                p->ebr = NULL;
-                if (decode_part(&(mbr->raw_data.pte[i]), p, 0)) {
+                rc_ext = decode_part(&(mbr->raw_data.pte[i]), p, 0);
+                mbr_set_flag(p, ST_LOGIC, false);
+                rc = mbr_add_partition(parts, p);
+                if (rc != ERR_OK) {
+                        printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \
+                                   LIBMBR_NAME ": Partition list may be incomplete.\n", rc);
+                        return NULL;
+                }
+                
+                if (rc_ext) {
                         ext = p;
                         parts->l_extended = list_last(&(parts->list));
                 }
-                mbr_set_flag(p, ST_LOGIC, false);
-                mbr_add_partition(parts, p);
-        }
-
+        }
+        
         // Fill in the primary partitions and generate logical ones, if any
         rc = decode_logical(mbr, parts, ext);
@@ -169 +178 @@
                            LIBMBR_NAME ": Partition list may be incomplete.\n");
         }
-
+        
+        //DEBUG:
+        //debug_print((unsigned char *) list_get_instance(list_last(&(parts->list)), mbr_part_t, link)->ebr, 512);
         return parts;
 }
@@ -188 +199 @@
         mbr_part_t * ext = (parts->l_extended == NULL) ? NULL
                                         : list_get_instance(parts->l_extended, mbr_part_t, link);
-
+        
         //br_block_t * last_ebr = NULL;
         //link_t * it;
-
+        
         DEBUG_PRINT_3(LIBMBR_NAME "Writing partitions: n_primary: %u, n_logical:%u, l_extended:%p", parts->n_primary, parts->n_logical, parts->l_extended);
-
+        
         rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
         if (rc != EOK) {
@@ -228 +239 @@
 
         }*/
-
+        
         link_t * l = parts->list.head.next;
-
+        
         // Encoding primary partitions
         for (i = 0; i < parts->n_primary; i++) {
                 p = list_get_instance(l, mbr_part_t, link);
-                encode_part(p, &(mbr->raw_data.pte[i]), 0);
+                encode_part(p, &(mbr->raw_data.pte[i]), 0, false);
                 l = l->next;
         }
-
+        
         // Writing MBR
         rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
@@ -244 +255 @@
                 goto end;
         }
-
+        
         if (ext == NULL)
                 goto no_extended;
-
-
+        
+        //DEBUG:
+        //debug_print((unsigned char *) list_get_instance(list_last(&(parts->list)), mbr_part_t, link)->ebr, 512);
         uint32_t base = ext->start_addr;
-        uint32_t addr = base;
-
+        //uint32_t addr = base;
+        //uint32_t prev_addr;
+        //mbr_part_t * tmp;
+        mbr_part_t * prev_p;
         // Encoding and writing first logical partition
         if (l != &(parts->list.head)) {
                 p = list_get_instance(l, mbr_part_t, link);
-                if (p->ebr == NULL) {
-                        p->ebr = alloc_br();
-                        if (p->ebr == NULL) {
-                                rc = ENOMEM;
-                                goto end;
-                        }
-                }
-
-                encode_part(p, &(p->ebr->pte[0]), base);
-
-                if (l->next == &(parts->list.head))
-                        encode_part(NULL, &(p->ebr->pte[1]), base);
-                else
-                        encode_part(list_get_instance(l->next, mbr_part_t, link), &(p->ebr->pte[1]), base);
-
-
+                p->ebr_addr = base;
+                encode_part(p, &(p->ebr->pte[0]), base, false);
+                
+                /*if (l->next == &(parts->list.head))
+                        encode_part(NULL, &(p->ebr->pte[1]), base, false);
+                else {
+                        tmp = list_get_instance(l->next, mbr_part_t, link);
+                        //debug_print((unsigned char*) p->ebr, 512);
+                        printf("DEBUG: base: %u, tmp: start: %u, end: %u\n", base, tmp->start_addr, tmp->start_addr + tmp->length);
+                        //encode_part(tmp, &(p->ebr->pte[1]), base);
+                        encode_part(tmp, &(p->ebr->pte[1]), base, true);
+                        debug_print(((unsigned char*) p->ebr) + 446, 32);
+                }
+                
                 rc = block_write_direct(dev_handle, base, 1, p->ebr);
                 if (rc != EOK) {
                         DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
                         goto end;
-                }
-
+                }*/
+                
                 l = l->next;
-        }
-
-
-
+        } else
+                goto no_logical;
+        
+        //prev_addr = base;
+        prev_p = p;
+        
         // Encoding and writing logical partitions
         while (l != &(parts->list.head)) {
                 p = list_get_instance(l, mbr_part_t, link);
-                if (p->ebr == NULL) {
-                        p->ebr = alloc_br();
-                        if (p->ebr == NULL) {
-                                rc = ENOMEM;
-                                goto end;
-                        }
-                }
-
-                addr = p->start_addr - base;
-                encode_part(p, &(p->ebr->pte[0]), addr);
-
-                if (l->next == &(parts->list.head))
-                        encode_part(NULL, &(p->ebr->pte[1]), base);
+                
+                /* Checking whether EBR address makes sense. If not, we take a guess.
+                 * So far this is simple, we just take the first preceeding sector.
+                 * Fdisk always reserves at least 2048 sectors (1MiB), so it can have 
+                 * the EBR aligned as well as the partition itself. Parted reserves
+                 * minimum one sector, like we do.
+                 * 
+                 * Note that we know there is at least one sector free from previous checks.
+                 * Also note that the user can set ebr_addr to their liking (if it's valid). */          
+                if (p->ebr_addr >= p->start_addr || p->ebr_addr <= (prev_p->start_addr + prev_p->length)) {
+                        p->ebr_addr = p->start_addr - 1;
+                        DEBUG_PRINT_0(LIBMBR_NAME ": Warning: invalid EBR address.\n");
+                }
+                
+                encode_part(p, &(p->ebr->pte[0]), p->ebr_addr, false);
+                debug_print(((unsigned char*) p->ebr) + 446, 32);
+                encode_part(p, &(prev_p->ebr->pte[1]), base, true);
+                debug_print(((unsigned char*) prev_p->ebr) + 446, 32);
+                /*if (l->next == &(parts->list.head))
+                        encode_part(NULL, &(p->ebr->pte[1]), base, false);
                 else
-                        encode_part(list_get_instance(l->next, mbr_part_t, link), &(p->ebr->pte[1]), base);
-
-
-                rc = block_write_direct(dev_handle, addr, 1, p->ebr);
+                        encode_part(list_get_instance(l->next, mbr_part_t, link), &(p->ebr->pte[1]), base, true);
+                */
+                
+                rc = block_write_direct(dev_handle, prev_p->ebr_addr, 1, prev_p->ebr);
                 if (rc != EOK) {
                         DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
                         goto end;
                 }
-
+                
+                prev_p = p;
                 l = l->next;
         }
-
+        
+        encode_part(NULL, &(prev_p->ebr->pte[1]), 0, false);
+        rc = block_write_direct(dev_handle, prev_p->ebr_addr, 1, prev_p->ebr);
+        if (rc != EOK) {
+                DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
+                goto end;
+        }
+        
+no_logical:
 no_extended:
-
+        
         /*if (ext == NULL)
                 goto no_extended;
@@ -514 +544 @@
                 p = p->next;
         }*/
-
+        
         rc = EOK;
-
+        
 end:
         block_fini(dev_handle);
-
+        
         return rc;
 }
@@ -536 +566 @@
         p->start_addr = 0;
         p->length = 0;
+        p->ebr_addr = 0;
 
         return p;
@@ -561 +592 @@
 int mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * p)
 {
-        if (mbr_get_flag(p, ST_LOGIC)) {
-                // adding logical part
+        if (mbr_get_flag(p, ST_LOGIC)) { // adding logical part
                 if (parts->l_extended == NULL) {
                         return ERR_NO_EXTENDED;
                 }
-                if (!check_encaps(p, list_get_instance(parts->l_extended, mbr_part_t, link))) {
+                mbr_part_t * ext = list_get_instance(parts->l_extended, mbr_part_t, link);
+                if (!check_encaps(p, ext)) {
+                        //printf("DEBUG: OOB: start: %u, end: %u\n", h->start_addr, h->start_addr + h->length);
+                        //printf("DEBUG: OOB: start: %u, end: %u\n", p->start_addr, p->start_addr + p->length);
                         return ERR_OUT_BOUNDS;
                 }
 
                 mbr_part_t * last = list_get_instance(list_last(&(parts->list)), mbr_part_t, link);
+                mbr_part_t * iter;
+                uint32_t ebr_space = 1;
                 mbr_part_foreach(parts, iter) {
                         if (mbr_get_flag(iter, ST_LOGIC)) {
                                 if (check_overlap(p, iter)) {
+                                        //printf("DEBUG: overlap: start: %u, end: %u\n", iter->start_addr, iter->start_addr + iter->length);
+                                        //printf("DEBUG: overlap: start: %u, end: %u\n", p->start_addr, p->start_addr + p->length);
                                         return ERR_OVERLAP;
                                 }
-                                if (check_preceeds(p, iter)) {
+                                if (check_preceeds(iter, p)) {
                                         last = iter;
+                                        ebr_space = p->start_addr - (last->start_addr + last->length);
+                                } else
                                         break;
-                                }
                         }
                 }
-
+                
+                // checking if there's at least one sector of space preceeding
+                
+                if (ebr_space < 1)
+                        return ERR_NO_EBR;
+                
+                // checking if there's at least one sector of space following (for following partitions's EBR)
+                if (last->link.next != &(parts->list.head)) {
+                        if (list_get_instance(&(last->link.next), mbr_part_t, link)->start_addr <= p->start_addr + p->length + 1) {
+                                return ERR_NO_EBR;
+                        }
+                }
+                
+                if (p->ebr == NULL) {
+                        p->ebr = alloc_br();
+                        if (p->ebr == NULL) {
+                                return ERR_NOMEM;
+                        }
+                }
+                
+                //printf("DEBUG: last: start: %u\n", last->start_addr);
                 //list_prepend(&(p->link), &(parts->list));
-                list_insert_before(&(p->link), &(last->link));
+                list_insert_after(&(p->link), &(last->link));
                 parts->n_logical += 1;
         } else {
@@ -591 +649 @@
                         return ERR_PRIMARY_FULL;
                 }
+                
+                // should we check if it's inside the drive's upper boundary?
+                if (p->start_addr == 0) {
+                        return ERR_OUT_BOUNDS;
+                }
+                
                 if (p->type == PT_EXTENDED && parts->l_extended != NULL) {
                         return ERR_EXTENDED_PRESENT;
@@ -598 +662 @@
                         list_append(&(p->link), &(parts->list));
                 } else {
+                        mbr_part_t * iter;
                         mbr_part_foreach(parts, iter) {
                                 if (mbr_get_flag(iter, ST_LOGIC)) {
                                         list_insert_before(&(p->link), &(iter->link));
-                                        parts->n_primary += 1;
                                         break;
                                 } else if (check_overlap(p, iter)) {
@@ -607 +671 @@
                                 }
                         }
-                }
+                        if (iter == list_get_instance(&(parts->list.head.prev), mbr_part_t, link)) {
+                                list_append(&(p->link), &(parts->list));
+                        }
+                        
+                }
+                parts->n_primary += 1;
         }
 
@@ -663 +732 @@
 }
 
+/** Get next aligned address (in sectors!) */
+uint32_t mbr_get_next_aligned(uint32_t addr, unsigned int alignment)
+{
+        uint32_t div = addr / alignment;
+        return (div + 1) * alignment;
+}
+
 /** Just a wrapper for free() */
 void mbr_free_mbr(mbr_t * mbr)
@@ -691 +767 @@
         if (br == NULL)
                 return NULL;
-
+        
+        memset(br, 0, 512);
         br->media_id = 0;
         br->pad0 = 0;
         br->signature = host2uint16_t_le(BR_SIGNATURE);
-
+        
         return br;
 }
@@ -733 +810 @@
         uint32_t addr = base;
         br_block_t * ebr;
-
+        
         rc = block_init(EXCHANGE_ATOMIC, mbr->device, 512);
         if (rc != EOK)
                 return rc;
-
+        
         ebr = alloc_br();
         if (ebr == NULL) {
@@ -743 +820 @@
                 goto end;
         }
-
+        
         rc = block_read_direct(mbr->device, addr, 1, ebr);
         if (rc != EOK) {
                 goto free_ebr_end;
         }
-
+        
         if (uint16_t_le2host(ebr->signature) != BR_SIGNATURE) {
                 rc = EINVAL;
                 goto free_ebr_end;
         }
-
+        
         if (ebr->pte[0].ptype == PT_UNUSED) {
                 rc = EOK;
                 goto free_ebr_end;
         }
-
+        
         p = mbr_alloc_partition();
         if (p == NULL) {
@@ -764 +841 @@
                 goto free_ebr_end;
         }
-
-
+        
         decode_part(&(ebr->pte[0]), p, base);
         mbr_set_flag(p, ST_LOGIC, true);
         p->ebr = ebr;
-        mbr_add_partition(parts, p);
-
+        p->ebr_addr = addr;
+        rc = mbr_add_partition(parts, p);
+        if (rc != ERR_OK) {
+                printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \
+                           LIBMBR_NAME ": Partition list may be incomplete.\n", rc);
+                return EINVAL;
+        }
+        
         addr = uint32_t_le2host(ebr->pte[1].first_lba) + base;
-
+        printf("DEBUG: b: %u, a: %u, start: %u\n", base, addr, ebr->pte[1].first_lba);
+        
         while (ebr->pte[1].ptype != PT_UNUSED) {
                 ebr = alloc_br();
@@ -779 +862 @@
                         goto end;
                 }
-
+                
                 rc = block_read_direct(mbr->device, addr, 1, ebr);
                 if (rc != EOK) {
                         goto free_ebr_end;
                 }
-
+                
                 if (uint16_t_le2host(ebr->signature) != BR_SIGNATURE) {
                         rc = EINVAL;
                         goto free_ebr_end;
                 }
-
+                
                 p = mbr_alloc_partition();
                 if (p == NULL) {
@@ -795 +878 @@
                         goto free_ebr_end;
                 }
-
-                decode_part(&(ebr->pte[0]), p, base);
+                
+                //printf("DEBUG: b: %u, a: %u, start: %u\n", base, addr, ebr->pte[0].first_lba);
+                decode_part(&(ebr->pte[0]), p, addr);
                 mbr_set_flag(p, ST_LOGIC, true);
                 p->ebr = ebr;
-                mbr_add_partition(parts, p);
-
+                p->ebr_addr = addr;
+                rc = mbr_add_partition(parts, p);
+                if (rc != ERR_OK) {
+                        printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \
+                                   LIBMBR_NAME ": Partition list may be incomplete.\n", rc);
+                        return EINVAL;
+                }
+                
                 addr = uint32_t_le2host(ebr->pte[1].first_lba) + base;
         }
-
+        
         rc = EOK;
-
+        goto end;
+        
 free_ebr_end:
         free(ebr);
-
+        
 end:
         block_fini(mbr->device);
-
+        
         return rc;
 }
 
 /** Convert mbr_part_t to pt_entry_t */
-static void encode_part(mbr_part_t * src, pt_entry_t * trgt, uint32_t base)
+static void encode_part(mbr_part_t * src, pt_entry_t * trgt, uint32_t base, bool ebr)
 {
         if (src != NULL) {
                 trgt->status = mbr_get_flag(src, ST_BOOT) ? B_ACTIVE : B_INACTIVE;
-                trgt->ptype = src->type;
-                trgt->first_lba = host2uint32_t_le(src->start_addr - base);
-                trgt->length = host2uint32_t_le(src->length);
+                if (ebr) {      // encoding reference to EBR
+                        trgt->ptype = PT_EXTENDED_LBA;
+                        trgt->first_lba = host2uint32_t_le(src->ebr_addr - base);
+                        trgt->length = host2uint32_t_le(src->length + src->start_addr - src->ebr_addr);
+                } else {        // encoding reference to partition
+                        trgt->ptype = src->type;
+                        trgt->first_lba = host2uint32_t_le(src->start_addr - base);
+                        trgt->length = host2uint32_t_le(src->length);
+                }
         } else {
                 trgt->status = 0;
@@ -839 +936 @@
 static int check_overlap(mbr_part_t * p1, mbr_part_t * p2)
 {
-        if (p1->start_addr < p2->start_addr && p1->start_addr + p1->length <= p2->start_addr) {
+        if (p1->start_addr < p2->start_addr && p1->start_addr + p1->length < p2->start_addr) {
                 return 0;
-        } else if (p1->start_addr > p2->start_addr && p2->start_addr + p2->length <= p1->start_addr) {
+        } else if (p1->start_addr > p2->start_addr && p2->start_addr + p2->length < p1->start_addr) {
                 return 0;
         }
@@ -864 +961 @@
 }
 
-
-
+static void debug_print(unsigned char * data, size_t bytes)
+{
+        size_t addr = 0;
+        int i;
+        
+        while (bytes >= 16) {
+                printf("%8x ", addr);
+                for (i = 0; i < 8; i++) {
+                        printf(" %2hhx", data[addr + i]);
+                }
+                printf(" ");
+                for (i = 0; i < 8; i++) {
+                        printf(" %2hhx", data[addr + i + 8]);
+                }
+                printf("\n");
+                
+                bytes -= 16;
+                addr += 16;
+        }
+        
+        
+}
+
+
+

uspace/lib/mbr/libmbr.h

@@ -84 +84 @@
         /** Extended partition */
         PT_EXTENDED     = 0x05,
+        /** Extended partition with LBA */
+        PT_EXTENDED_LBA = 0x0F,
         /** GPT Protective partition */
         PT_GPT  = 0xEE,
@@ -101 +103 @@
         /** Logical partition out of bounds */
         ERR_OUT_BOUNDS,
+        /** No space left for EBR */
+        ERR_NO_EBR,
+        /** Out of memory */
+        ERR_NOMEM,
 } MBR_ERR_VAL;
 
@@ -156 +162 @@
         /** Points to Extended Boot Record of logical partition */
         br_block_t * ebr;
+        /** EBR address */
+        uint32_t ebr_addr;
 } mbr_part_t;
 
@@ -194 +202 @@
 extern int                      mbr_get_flag(mbr_part_t * p, MBR_FLAGS flag);
 extern void                     mbr_set_flag(mbr_part_t * p, MBR_FLAGS flag, bool value);
+extern uint32_t         mbr_get_next_aligned(uint32_t addr, unsigned int alignment);
 
 #define mbr_part_foreach(parts, iterator)       \
-                        for (mbr_part_t * iterator = list_get_instance((parts)->list.head.next, mbr_part_t, link); \
-                                iterator != list_get_instance(&(parts)->list.head, mbr_part_t, link); \
-                                iterator = list_get_instance(iterator->link.next, mbr_part_t, link))
+                        for (iterator  = list_get_instance((parts)->list.head.next, mbr_part_t, link); \
+                                 iterator != list_get_instance(&((parts)->list.head), mbr_part_t, link); \
+                                 iterator  = list_get_instance(iterator->link.next, mbr_part_t, link))