Changeset 30440ed in mainline

Timestamp:

2013-04-08T23:15:42Z (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:

256cbfe

Parents:

271e24a

Message:

save progress

Location:

uspace

Files:

• app/hdisk/func_gpt.c (modified) (2 diffs)
• app/hdisk/func_gpt.h (modified) (1 diff)
• app/hdisk/func_mbr.c (modified) (6 diffs)
• app/hdisk/func_mbr.h (modified) (1 diff)
• app/hdisk/hdisk.c (modified) (5 diffs)
• app/hdisk/hdisk.h (added)
• lib/gpt/global.c (added)
• lib/gpt/libgpt.c (modified) (12 diffs)
• lib/gpt/libgpt.h (modified) (4 diffs)
• lib/mbr/Makefile (modified) (1 diff)
• lib/mbr/libmbr.c (modified) (16 diffs)
• lib/mbr/libmbr.h (modified) (5 diffs)

uspace/app/hdisk/func_gpt.c

@@ -35 +35 @@
 #include <stdio.h>
 #include <errno.h>
+#include <str_error.h>
 #include <sys/types.h>
 
 #include "func_gpt.h"
+#include "input.h"
+
+static int set_gpt_partition(tinput_t *, gpt_part_t *);
 
 int add_gpt_part(tinput_t * in, union table_data * data)
 {
-        int rc = EOK;
+        gpt_part_t * p = gpt_alloc_partition(data->gpt.parts);
+        if (p == NULL) {
+                return ENOMEM;
+        }
         
-        return rc;
+        return set_gpt_partition(in, p);
 }
 
 int delete_gpt_part(tinput_t * in, union table_data * data)
 {
-        int rc = EOK;
+        size_t idx;
+
+        printf("Number of the partition to delete (counted from 0): ");
+        idx = get_input_size_t(in);
         
-        return rc;
+        if (gpt_remove_partition(data->gpt.parts, idx) == -1) {
+                printf("Warning: running low on memory, not resizing...\n");
+        }
+        
+        return EOK;
 }
 
 int print_gpt_parts(union table_data * data)
 {
-        int rc = EOK;
+        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));
+        }
         
         return rc;
@@ -62 +82 @@
 int write_gpt_parts(service_id_t dev_handle, union table_data * data)
 {
-        int rc = EOK;
+        int rc;
         
-        return rc;
+        rc = gpt_write_partitions(data->gpt.parts, data->gpt.gpt, dev_handle);
+        if (rc != EOK) {
+                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
+                return rc;
+        }
+        
+        rc = gpt_write_gpt_header(data->gpt.gpt, dev_handle);
+        if (rc != EOK) {
+                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
+                return rc;
+        }
+        
+        return EOK;
 }
 
+int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
+{
+        return EOK;
+}
+
+static int set_gpt_partition(tinput_t * in, gpt_part_t * p)
+{
+        int rc;
+        
+        uint64_t sa, ea;
+        
+        printf("Set starting address (number): ");
+        sa = get_input_uint64(in);
+
+        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;
+        
+        return EOK;
+}
+

uspace/app/hdisk/func_gpt.h

@@ -46 +46 @@
 extern int print_gpt_parts(union table_data * data);
 extern int write_gpt_parts(service_id_t dev_handle, union table_data * data);
+extern int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data);
 
 #endif

uspace/app/hdisk/func_mbr.c

@@ -35 +35 @@
 #include <stdio.h>
 #include <errno.h>
+#include <str_error.h>
 #include <sys/types.h>
 
@@ -94 +95 @@
                         printf(" ");
 
-                printf("\t\t%u\t%u\t%u\t%d\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
+                printf("\t%10u %10u %10u %3d\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
 
                 ++num;
@@ -108 +109 @@
         int rc = mbr_write_partitions(data->mbr.parts, data->mbr.mbr, dev_handle);
         if (rc != EOK) {
-                printf("Error occured during writing. (ERR: %d)\n", rc);
+                printf("Error occured during writing: ERR: %d: %s\n", rc, str_error(rc));
         }
         
@@ -114 +115 @@
 }
 
-
+int extra_mbr_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
+{
+        return EOK;
+}
 
 static int set_mbr_partition(tinput_t * in, mbr_part_t * p)
@@ -123 +127 @@
         printf("Primary (p) or logical (l): ");
         c = getchar();
+        printf("%c\n", c);
 
         switch(c) {
                 case 'p':
                         mbr_set_flag(p, ST_LOGIC, false);
+                        break;
                 case 'l':
                         mbr_set_flag(p, ST_LOGIC, true);
+                        break;
                 default:
                         printf("Invalid type. Cancelled.");
@@ -144 +151 @@
                 return EINVAL;
         }
-        
+        printf("%c\n", c);
         mbr_set_flag(p, ST_BOOT, (c == 'y' || c == 'Y') ? true : false);
 

uspace/app/hdisk/func_mbr.h

@@ -46 +46 @@
 extern int print_mbr_parts(union table_data * data);
 extern int write_mbr_parts(service_id_t dev_handle, union table_data * data);
+extern int extra_mbr_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data);
 
 #endif

uspace/app/hdisk/hdisk.c

@@ -175 +175 @@
                 return ENOMEM;
         }
+        tinput_set_prompt(in, "");
 
         printf("Welcome to hdisk.\nType 'h' for help.\n");
@@ -184 +185 @@
         while (1) {
 
-                //printf("# ");
+                printf("# ");
                 input = getchar();
-                //printf("%c\n", input);
+                printf("%c\n", input);
                 
 
@@ -210 +211 @@
                                 table.delete_part(in, &table.data);
                                 break;
+                        case 'e':
+                                table.extra_funcs(in, dev_handle, &table.data);
+                                break;
                         case 'h':
                                 print_help();
@@ -259 +263 @@
                         table.print_parts = print_mbr_parts;
                         table.write_parts = write_mbr_parts;
+                        table.extra_funcs = extra_mbr_funcs;
                         break;
                 case LYT_GPT:
@@ -265 +270 @@
                         table.print_parts = print_gpt_parts;
                         table.write_parts = write_gpt_parts;
+                        table.extra_funcs = extra_gpt_funcs;
                         break;
                 default:

uspace/lib/gpt/libgpt.c

@@ -117 +117 @@
  * 
  * @return                              0 on success, libblock error code otherwise
+ * 
+ * Note: Firstly write partitions (if changed), then gpt header.
  */
 int gpt_write_gpt_header(gpt_t * gpt, service_id_t dev_handle)
@@ -167 +169 @@
         unsigned int i;
         gpt_partitions_t * res;
-        uint32_t num_ent = uint32_t_le2host(gpt->raw_data->num_entries);
+        uint32_t fill = uint32_t_le2host(gpt->raw_data->fillries);
         uint32_t ent_size = uint32_t_le2host(gpt->raw_data->entry_size);
         uint64_t ent_lba = uint64_t_le2host(gpt->raw_data->entry_lba);
         
-        res = alloc_part_array(num_ent);
+        res = alloc_part_array(fill);
         if (res == NULL) {
                 //errno = ENOMEM; // already set in alloc_part_array()
@@ -204 +206 @@
          * will always read just sizeof(gpt_entry_t) bytes - hopefully they
          * don't break backward compatibility) */
-        for (i = 0; i < num_ent; ++i) {
+        for (i = 0; i < fill; ++i) {
                 //FIXME: this does bypass cache...
                 rc = block_read_bytes_direct(gpt->device, pos, sizeof(gpt_entry_t), res->part_array + i);
@@ -223 +225 @@
          * on all of the partition entry array.
          */
-        uint32_t crc = compute_crc32((uint8_t *) res->part_array, res->num_ent * sizeof(gpt_entry_t));
+        uint32_t crc = compute_crc32((uint8_t *) res->part_array, res->fill * sizeof(gpt_entry_t));
         
         if(uint32_t_le2host(gpt->raw_data->pe_array_crc32) != crc)
@@ -247 +249 @@
         size_t b_size;
         
-        gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->num_ent * gpt->raw_data->entry_size);
+        gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->fill * gpt->raw_data->entry_size);
         
         rc = block_get_bsize(dev_handle, &b_size);
@@ -259 +261 @@
         /* Write to main GPT partition array location */
         rc = block_write_direct(dev_handle, uint64_t_le2host(gpt->raw_data->entry_lba), 
-                        nearest_larger_int((uint64_t_le2host(gpt->raw_data->entry_size) * parts->num_ent) / b_size), 
+                        nearest_larger_int((uint64_t_le2host(gpt->raw_data->entry_size) * parts->fill) / b_size), 
                         parts->part_array);
         if (rc != EOK)
@@ -277 +279 @@
         
         
-        gpt_write_gpt_header(gpt, dev_handle);
-        
-        return 0;
-        
-}
-
-gpt_partitions_t * gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition)
-{
-        
+        return gpt_write_gpt_header(gpt, dev_handle);
+}
+
+/** Alloc new partition
+ * 
+ * @param parts         partition table to carry new partition
+ * 
+ * @return                      returns pointer to the new partition or NULL on ENOMEM
+ * 
+ * Note: use either gpt_alloc_partition or gpt_add_partition. The first
+ * returns a pointer to write your data to, the second copies the data 
+ * (and does not free the memory).
+ */
+gpt_part_t * gpt_alloc_partition(gpt_partitions_t * parts)
+{
+        if (parts->fill == parts->arr_size) {
+                if (extend_part_array(parts) == -1)
+                        return NULL;
+        }
+        
+        return parts->part_array + parts->fill++;
+}
+
+/** Copy partition into partition array
+ * 
+ * @param parts                 target partition array
+ * @param partition             source partition to copy
+ * 
+ * @return                              -1 on error, 0 otherwise
+ * 
+ * Note: use either gpt_alloc_partition or gpt_add_partition. The first
+ * returns a pointer to write your data to, the second copies the data 
+ * (and does not free the memory).
+ */
+int gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition)
+{
+        if (parts->fill == parts->arr_size) {
+                if (extend_part_array(parts) == -1)
+                        return -1;
+        }
         extend_part_array(parts);
         return parts;
 }
 
-gpt_partitions_t * gpt_remove_partition(gpt_partitions_t * parts, size_t idx)
-{
-        reduce_part_array(parts);
-        return parts;
+/** Remove partition from array
+ * 
+ * @param idx           index of the partition to remove
+ * 
+ * @return                      -1 on error, 0 otherwise
+ * 
+ * Note: even if it fails, the partition still gets removed. Only
+ * reducing the array failed.
+ */
+int gpt_remove_partition(gpt_partitions_t * parts, size_t idx)
+{
+        if (idx != parts->fill - 1) {
+                memcpy(parts->part_array + idx, parts->part_array + fill - 1, sizeof(gpt_entry_t));
+                parts->fill -= 1;
+        }
+        
+        if (parts->fill < (parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
+                if (reduce_part_array(parts) == -1)
+                        return -1;
+        }
+        
+        return 0;
 }
 
@@ -311 +362 @@
         free(parts->part_array);
         free(parts);
+}
+
+/** Get partition type by linear search
+ * (hopefully this doesn't get slow)
+ */
+size_t gpt_get_part_type(gpt_part_t * p)
+{
+        size_t i;
+        for (i = 0; gpt_ptypes[i].guid != NULL; i++) {
+                if (memcmp(p->raw_data.part_type, gpt_ptypes[i].guid, 16) == 0) {
+                        break;
+                }
+        }
+        return i;
 }
 
@@ -343 +408 @@
 }
 
+char * gpt_get_part_name(gpt_entry_t * p)
+{
+        return p->raw_data.part_name;
+}
+
 /** Copy partition name */
 void gpt_set_part_name(gpt_entry_t * p, char * name[], size_t length)
 {
+        if (length >= 72)
+                length = 71;
+        
         memcpy(p->part_name, name, length);
+        p->part_name[length] = '\0';
+}
+
+/** Get partition attribute */
+extern bool gpt_get_flag(gpt_part_t * p, GPT_ATTR flag)
+{
+        return (p->raw_data.attributes & (((uint64_t) 1) << flag)) ? 1 : 0;
+}
+
+/** Set partition attribute */
+extern void gpt_set_flag(gpt_part_t * p, GPT_ATTR flag, bool value)
+{
+        uint64_t attr = p->raw_data.attributes;
+
+        if (value)
+                attr = attr | (((uint64_t) 1) << flag);
+        else
+                attr = attr ^ (attr & (((uint64_t) 1) << flag));
+
+        p->raw_data.attributes = attr;
 }
 
@@ -405 +498 @@
         }
         
-        res->num_ent = num;
+        res->fill = num;
         res->arr_size = size;
         
@@ -420 +513 @@
         }
         
-        memcpy(tmp, p->part_array, p->num_ent);
+        memcpy(tmp, p->part_array, p->fill);
         free(p->part_array);
         p->part_array = tmp;
@@ -438 +531 @@
                 }
                 
-                memcpy(tmp, p->part_array, p->num_ent < nsize ? p->num_ent : nsize);
+                memcpy(tmp, p->part_array, p->fill < nsize ? p->fill  : nsize);
                 free(p->part_array);
                 p->part_array = tmp;

uspace/lib/gpt/libgpt.h

@@ -49 +49 @@
 /** Basic number of GPT partition entries */
 #define GPT_BASE_PART_NUM (GPT_MIN_PART_NUM)
+/** How much fill we ignore before resizing partition array */
+#define GPT_IGNORE_FILL_NUM 10
 
 /** GPT header signature ("EFI PART" in ASCII) */
 extern const uint8_t efi_signature[8];
+
+typedef enum {
+        AT_REQ_PART = 0,
+        AT_NO_BLOCK_IO,
+        AT_LEGACY_BOOT,
+        AT_UNDEFINED,
+        AT_SPECIFIC = 48
+} GPT_ATTR;
 
 /** GPT header
@@ -68 +78 @@
         uint8_t disk_guid[16];
         uint64_t entry_lba;
-        uint32_t num_entries;
+        uint32_t fillries;
         uint32_t entry_size;
         uint32_t pe_array_crc32;
@@ -105 +115 @@
 typedef struct gpt_parts {
         /** Number of entries */
-        unsigned int num_ent;
+        size_t fill;
         /** Size of the array */
-        unsigned int arr_size;
+        size_t arr_size;
         /** Resizable partition array */
         gpt_entry_t * part_array;
@@ -132 +142 @@
 extern gpt_partitions_t * gpt_read_partitions(gpt_t * gpt);
 extern int                                gpt_write_partitions(gpt_partitions_t * parts, gpt_t * header, service_id_t dev_handle);
-extern gpt_partitions_t * gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition);
-extern gpt_partitions_t * gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
-extern void                       gpt_set_part_type(gpt_part_t * p, int type);
+extern gpt_part_t *               gpt_alloc_partition(gpt_partitions_t * parts);
+extern int                                gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition);
+extern int                                gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
+extern size_t                     gpt_get_part_type(gpt_part_t * p);
+extern void                       gpt_set_part_type(gpt_part_t * p, size_t type);
+extern char *                     gpt_get_part_name(gpt_entry_t * p);
 extern void                       gpt_set_part_name(gpt_entry_t * p, char * name[], size_t length);
+extern bool                               gpt_get_flag(gpt_part_t * p, GPT_ATTR flag);
+extern void                               gpt_set_flag(gpt_part_t * p, GPT_ATTR flag, bool value);
+
+#define gpt_foreach(parts, i, iterator) \
+                for(size_t i = 0, gpt_part_t * iterator = parts->part_array;
+                    i < parts->fill; i++, iterator++)
 
 extern void gpt_free_gpt(gpt_t * gpt);

uspace/lib/mbr/Makefile

@@ -28 +28 @@
 
 USPACE_PREFIX = ../..
-EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -DDEBUG_CONFIG
 LIBRARY = libmbr
 

uspace/lib/mbr/libmbr.c

@@ -150 +150 @@
                         return NULL;
                 }
-                list_append(&(p->link), &(parts->list));
+                //list_append(&(p->link), &(parts->list));
                 p->ebr = NULL;
-                if (decode_part(&(mbr->raw_data.pte[i]), p, 0))
+                if (decode_part(&(mbr->raw_data.pte[i]), p, 0)) {
                         ext = p;
+                        parts->l_extended = list_last(&(parts->list));
+                }
+                mbr_set_flag(p, ST_LOGIC, false);
+                mbr_add_partition(parts, p);
         }
 
@@ -183 +187 @@
         
         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) {
+                DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
                 return rc;
         }
@@ -193 +200 @@
                 goto no_extended;
 
-        aoff64_t addr = ext->start_addr;
+        uint32_t base = ext->start_addr;
+        uint32_t addr = base;
+        uint32_t prev_addr;
         mbr_part_t * prev_part = NULL;
 
-        list_foreach(parts->list, it) {
-                p = list_get_instance(it, mbr_part_t, link);
+        list_foreach(parts->list, iter) {
+                p = list_get_instance(iter, mbr_part_t, link);
                 if (mbr_get_flag(p, ST_LOGIC)) {
                         // writing logical partition
-
+                        
+                        if (p->start_addr < base || p->start_addr + p->length > base + ext->length) {
+                                // out of bounds
+                                return EINVAL;
+                        }
+                        
+                        
                         if (p->ebr == NULL) {
                                 p->ebr = alloc_br();
@@ -210 +225 @@
                         }
 
-
-                        encode_part(p, &(p->ebr->pte[0]), addr);
+                        
+                        
+                        
                         if (prev_part != NULL) {
-                                encode_part(p, &(prev_part->ebr->pte[1]), ext->start_addr);
-                                rc = block_write_direct(dev_handle, p->start_addr, 1, prev_part->ebr);
-                                if (rc != EOK)
+                                // addr is the address of EBR
+                                addr = p->start_addr - base;
+                                // base-1 means start_lba+1
+                                encode_part(p, &(p->ebr->pte[0]), addr - 1);
+                                encode_part(p, &(prev_part->ebr->pte[1]), base);
+                                rc = block_write_direct(dev_handle, prev_addr, 1, prev_part->ebr);
+                                if (rc != EOK) {
+                                        DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
                                         goto end;
+                                }
+                        } else {
+                                // addr is the address of EBR
+                                addr = base;
+                                // base-1 means start_lba+1
+                                encode_part(p, &(p->ebr->pte[0]), base - 1);
                         }
                         
-                        addr = p->start_addr;
+                        //addr = p->start_addr;
+                        prev_addr = addr;
                         prev_part = p;
                 } else {
@@ -261 +289 @@
         }
         
-        if (rc != EOK)
+        if (rc != EOK) {
+                DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
                 goto end;
+        }
 
         goto skip;
@@ -268 +298 @@
 no_extended:
 
-        list_foreach(parts->list, it) {
+        /*list_foreach(parts->list, it) {
                 p = list_get_instance(it, mbr_part_t, link);
                 if (mbr_get_flag(p, ST_LOGIC)) {
@@ -282 +312 @@
                         ++i;
                 }
-        }
+        }*/
+        
+        it = parts->list.head.next;
+        for (i = 0; i < N_PRIMARY; i++) {
+                if (it != &parts->list.head) {
+                        p = list_get_instance(it, mbr_part_t, link);
+                        if (mbr_get_flag(p, ST_LOGIC)) {
+                                // extended does not exist, fail
+                                return EINVAL;
+                        } else {
+                                // writing primary partition
+                                if (i >= 4)
+                                        return EINVAL;
+
+                                encode_part(p, &(mbr->raw_data.pte[i]), 0);
+
+                        }
+                        
+                        it = it->next;
+                } else {
+                        encode_part(NULL, &(mbr->raw_data.pte[i]), 0);
+                }
+        }
+        
 
 skip:
         rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
-        if (rc != EOK)
+        if (rc != EOK) {
+                DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
                 goto end;
+        }
 
         /*
@@ -382 +437 @@
 
         list_initialize(&(parts->list));
+        
+        parts->n_primary = 0;
+        parts->n_logical = 0;
+        parts->l_extended = NULL;
 
         return parts;
@@ -387 +446 @@
 
 /** Add partition */
-int mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * partition)
-{
-        list_append(&(partition->link), &(parts->list));
+int mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * p)
+{
+        list_append(&(p->link), &(parts->list));
+        if (mbr_get_flag(p, ST_LOGIC)) {
+                parts->n_logical += 1;
+        } else {
+                parts->n_primary += 1;
+        }
+        /* if we're adding new logical partition, we need 1 sector for the EBR 
+         * for that partition (including the next one); we'd better make sure here
+         * before writing */
+        if (mbr_get_flag(p, ST_LOGIC) && p->ebr == NULL) {
+                p->start_addr += 1;
+                p->length -= 1;
+        }
+        //FIXME: we can have multiple extended partitions! :-(
+        
         return EOK;
 }
@@ -396 +469 @@
 int mbr_remove_partition(mbr_partitions_t * parts, size_t idx)
 {
+        DEBUG_PRINT_1(LIBMBR_NAME "Removing partition: %d\n", idx);
         link_t * l = list_nth(&(parts->list), idx);
+        if (l == parts->l_extended) {
+                DEBUG_PRINT_0(LIBMBR_NAME "Removing extended partition.\n");
+                parts->l_extended = NULL;
+        }
         list_remove(l);
         mbr_part_t * p = list_get_instance(l, mbr_part_t, link);
+        if (mbr_get_flag(p, ST_LOGIC)) {
+                parts->n_logical -= 1;
+        } else {
+                parts->n_primary -= 1;
+        }
+        
+        
         mbr_free_partition(p);
         
@@ -448 +533 @@
                 mbr_free_partition(p);
         }
+        
+        free(parts);
 }
 
@@ -465 +552 @@
 }
 
-/** Parse partition entry to mbr_part_t */
+/** Parse partition entry to mbr_part_t
+ * @return              returns 1, if extended partition, 0 otherwise
+ * */
 static int decode_part(pt_entry_t * src, mbr_part_t * trgt, uint32_t base)
 {
@@ -480 +569 @@
 }
 
-/** Parse MBR contents to mbr_part_t list
- * parameter 'p' is allocated for only used primary partitions
- */
+/** Parse MBR contents to mbr_part_t list */
 static int decode_logical(mbr_t * mbr, mbr_partitions_t * parts, mbr_part_t * ext)
 {
@@ -496 +583 @@
 
 
-        uint32_t addr = ext->start_addr;
-        //uint32_t base = ext->start_addr;
+        uint32_t base = ext->start_addr;
+        uint32_t addr = base;
         br_block_t * ebr;
 
@@ -503 +590 @@
         if (rc != EOK)
                 return rc;
-
-        do {
+        
+        ebr = alloc_br();
+        if (ebr == NULL) {
+                rc = ENOMEM;
+                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) {
+                rc = ENOMEM;
+                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);
+
+        addr = uint32_t_le2host(ebr->pte[1].first_lba) + base;
+        
+        while (ebr->pte[1].ptype != PT_UNUSED) {
                 ebr = alloc_br();
                 if (ebr == NULL) {
-                        return ENOMEM;
+                        rc = ENOMEM;
+                        goto end;
                 }
 
                 rc = block_read_direct(mbr->device, addr, 1, ebr);
                 if (rc != EOK) {
-                        return rc;
-                }
-
-                //FIXME: is this the right way?
+                        goto free_ebr_end;
+                }
+
                 if (uint16_t_le2host(ebr->signature) != BR_SIGNATURE) {
-                        return EINVAL;
+                        rc = EINVAL;
+                        goto free_ebr_end;
                 }
 
                 p = mbr_alloc_partition();
-
-                decode_part(&(ebr->pte[0]), p, addr);
+                if (p == NULL) {
+                        rc = ENOMEM;
+                        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);
 
-                //TODO: Check this code
-                addr = ebr->pte[1].first_lba + ext->start_addr;
-        } while (ebr->pte[1].ptype != PT_UNUSED);
-
-
+                addr = uint32_t_le2host(ebr->pte[1].first_lba) + base;
+        }
+        
+        rc = EOK;
+        
+free_ebr_end:
+        free(ebr);
+        
+end:
         block_fini(mbr->device);
 
-        return EOK;
+        return rc;
 }
 
@@ -543 +674 @@
                 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 + 63); //63 sectors skipped
-                trgt->length = host2uint32_t_le(src->length - 64);      //63 + 1 (EBR)
+                trgt->first_lba = host2uint32_t_le(src->start_addr - base);
+                trgt->length = host2uint32_t_le(src->length);
         } else {
                 trgt->status = 0;

uspace/lib/mbr/libmbr.h

@@ -39 +39 @@
 
 #define LIBMBR_NAME     "libmbr"
+
+#ifdef DEBUG_CONFIG
+#include <stdio.h>
+#include <str_error.h>
+#define DEBUG_PRINT_0(str) \
+        printf("%s:%d: " str, __FILE__, __LINE__)
+#define DEBUG_PRINT_1(str, arg1) \
+        printf("%s:%d: " str, __FILE__, __LINE__, arg1)
+#define DEBUG_PRINT_2(str, arg1, arg2) \
+        printf("%s:%d: " str, __FILE__, __LINE__, arg1, arg2)
+#define DEBUG_PRINT_3(str, arg1, arg2, arg3) \
+        printf("%s:%d: " str, __FILE__, __LINE__, arg1, arg2, arg3)
+#else
+#define DEBUG_PRINT_0(str) 
+#define DEBUG_PRINT_1(str, arg1)
+#define DEBUG_PRINT_2(str, arg1, arg2)
+#define DEBUG_PRINT_3(str, arg1, arg2, arg3)
+#endif
 
 /** Number of primary partition records */
@@ -105 +123 @@
         /** Device where the data are from */
         service_id_t device;
-        /** Pointer to partition list */
-        //list of partitions;   //if we keep this in here, we should free() it in mbr_free_mbr()
 } mbr_t;
 
 
-//FIXME: make mbr_partitions_t as the linked list for keeping the same interface as with GPT
 /** Partition */
 typedef struct mbr_part {
@@ -127 +142 @@
 } mbr_part_t;
 
+/** Partition list structure */
 typedef struct mbr_parts {
         /** Number of primary partitions */
@@ -138 +154 @@
 } mbr_partitions_t;
 
+/** Both header and partition list */
 typedef struct mbr_table {
         mbr_t * mbr;
@@ -151 +168 @@
 extern int mbr_is_mbr(mbr_t * mbr);
 
-/** Read/Write/Set MBR partitions. */
+/** Read/Write/Set MBR partitions.
+ * NOTE: Writing partitions writes the complete header as well. */
 extern mbr_partitions_t * mbr_read_partitions(mbr_t * mbr);
 extern int                      mbr_write_partitions(mbr_partitions_t * parts, mbr_t * mbr, service_id_t dev_handle);