Changeset 283ea3d in mainline

Timestamp:

2013-07-28T22:52:16Z (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:

e3bc355

Parents:

8559fa0 (diff), 675de6d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

libmbr, libgpt and hdisk fixes and polishing

Location:

uspace

Files:

• app/hdisk/func_gpt.c (modified) (11 diffs)
• app/hdisk/hdisk.c (modified) (2 diffs)
• lib/gpt/gpt.h (added)
• lib/gpt/libgpt.c (modified) (27 diffs)
• lib/gpt/libgpt.h (modified) (5 diffs)
• lib/mbr/libmbr.c (modified) (3 diffs)
• lib/mbr/libmbr.h (modified) (3 diffs)
• lib/mbr/mbr.h (added)

uspace/app/hdisk/func_gpt.c

@@ -42 +42 @@
 #include "input.h"
 
-static int set_gpt_partition(tinput_t *, gpt_part_t *);
-
+static int set_gpt_partition(tinput_t *, gpt_part_t *, unsigned int);
 
 int construct_gpt_label(label_t *this)
@@ -50 +49 @@
         this->alignment = 1;
         
-        this->add_part    = add_gpt_part;
-        this->delete_part = delete_gpt_part;
-        this->new_label   = new_gpt_label;
-        this->print_parts = print_gpt_parts;
-        this->read_parts  = read_gpt_parts;
-        this->write_parts = write_gpt_parts;
-        this->extra_funcs = extra_gpt_funcs;
+        this->add_part      = add_gpt_part;
+        this->delete_part   = delete_gpt_part;
+        this->destroy_label = destroy_gpt_label;
+        this->new_label     = new_gpt_label;
+        this->print_parts   = print_gpt_parts;
+        this->read_parts    = read_gpt_parts;
+        this->write_parts   = write_gpt_parts;
+        this->extra_funcs   = extra_gpt_funcs;
         
         return this->new_label(this);
@@ -68 +68 @@
         }
         
-        return set_gpt_partition(in, p);
+        return set_gpt_partition(in, p, this->alignment);
 }
 
@@ -80 +80 @@
         
         rc = gpt_remove_partition(this->data.gpt, idx);
-        if (rc != EOK) {
+        if (rc == ENOMEM) {
                 printf("Warning: running low on memory, not resizing...\n");
                 return rc;
+        } else if (rc == EINVAL) {
+                printf("Invalid index.\n");
+                return rc;
         }
         
@@ -102 +105 @@
 int print_gpt_parts(label_t *this)
 {
-        //int rc;
         printf("Current partition scheme (GPT):\n");
-        printf("\t\tStart:\tEnd:\tLength:\tType:\tName:\n");
+        printf("%15s %10s %10s Type: Name:\n", "Start:", "End:", "Length:");
         
         size_t i = 0;
@@ -110 +112 @@
         gpt_part_foreach(this->data.gpt, iter) {
                 i++;
-                //FIXMEE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                
                 if (gpt_get_part_type(iter) == GPT_PTE_UNUSED)
                         continue;
@@ -117 +119 @@
                         printf("%15s %10s %10s Type: Name:\n", "Start:", "End:", "Length:");
                 
-                //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  %10llu %10llu %10llu    %3d %s\n", i-1, 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));
-        }
-        
-        //return rc;
+                
+        }
+        
         return EOK;
 }
@@ -172 +173 @@
 }
 
-static int set_gpt_partition(tinput_t *in, gpt_part_t *p)
+static int set_gpt_partition(tinput_t *in, gpt_part_t *p, unsigned int alignment)
 {
         int rc;
@@ -180 +181 @@
         printf("Set starting address (number): ");
         sa = get_input_uint64(in);
+        if (sa % alignment != 0)
+                sa = gpt_get_next_aligned(sa, alignment);
         
         printf("Set end addres (number): ");
@@ -192 +195 @@
         gpt_set_end_lba(p, ea);
         
+        //printf("Set type : ");
+        //size_t idx = get_input_size_t(in);
+        //gpt_set_part_type(p, idx);
+        
+        gpt_set_random_uuid(p->part_type);
+        gpt_set_random_uuid(p->part_id);
         
         char *name;
@@ -201 +210 @@
         }
         
-        printf("name: %s, len: %d\n", name, str_size(name));
         gpt_set_part_name(p, name, str_size(name));
         

uspace/app/hdisk/hdisk.c

@@ -144 +144 @@
         rc = interact(dev_handle);
         
-        free_label();
-        
         return rc;
 }
@@ -180 +178 @@
                                 break;
                         case 'f':
-                                free_label();
                                 select_label_format(in);
                                 break;

uspace/lib/gpt/libgpt.c

@@ -51 +51 @@
 #include "libgpt.h"
 
-static int load_and_check_header(service_id_t handle, aoff64_t addr, size_t b_size, gpt_header_t *header);
-static gpt_partitions_t * alloc_part_array(uint32_t num);
+static int load_and_check_header(service_id_t, aoff64_t, size_t, gpt_header_t *);
+static gpt_partitions_t * alloc_part_array(uint32_t);
 static int extend_part_array(gpt_partitions_t *);
 static int reduce_part_array(gpt_partitions_t *);
-static long long nearest_larger_int(double a);
+//static long long nearest_larger_int(double);
 static uint8_t get_byte(const char *);
-static int check_overlap(gpt_part_t * p1, gpt_part_t * p2);
+static bool check_overlap(gpt_part_t *, gpt_part_t *);
 
 /** Allocate memory for gpt label */
@@ -66 +66 @@
                 return NULL;
         
+        /* This is necessary so that gpt_part_foreach does not segfault */
+        label->parts = gpt_alloc_partitions();
+        if (label == NULL) {
+                free(label);
+                return NULL;
+        }
+        
         label->gpt = NULL;
-        label->parts = NULL;
+        
         label->device = 0;
         
@@ -92 +99 @@
                 return NULL;
         
-        // We might need only sizeof(gpt_header_t),
-        // but we should follow specs and have
-        // zeroes through all the rest of the block
+        /* 
+         * We might need only sizeof(gpt_header_t), but we should follow 
+         * specs and have zeroes through all the rest of the block
+         */
         size_t final_size = size > sizeof(gpt_header_t) ? size : sizeof(gpt_header_t);
         gpt->header = malloc(final_size);
@@ -178 +186 @@
         int rc;
         size_t b_size;
-
-        label->gpt->header->header_crc32 = 0;
-        label->gpt->header->header_crc32 = compute_crc32((uint8_t *) label->gpt->header,
-                                        uint32_t_le2host(label->gpt->header->header_size));
-
-        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
+        
+        /* The comm_size argument (the last one) is ignored */
+        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 4096);
         if (rc != EOK && rc != EEXIST)
                 return rc;
-
+        
         rc = block_get_bsize(dev_handle, &b_size);
         if (rc != EOK)
                 return rc;
-
-        /* Write to main GPT header location */
-        rc = block_write_direct(dev_handle, GPT_HDR_BA, GPT_HDR_BS, label->gpt->header);
-        if (rc != EOK) {
-                block_fini(dev_handle);
-                return rc;
-        }
-
+        
         aoff64_t n_blocks;
         rc = block_get_nblocks(dev_handle, &n_blocks);
@@ -204 +202 @@
                 return rc;
         }
-
+        
+        uint64_t tmp;
+        
+        /* Prepare the backup header */
+        label->gpt->header->alternate_lba = label->gpt->header->my_lba;
+        label->gpt->header->my_lba = host2uint64_t_le(n_blocks - 1);
+        
+        tmp = label->gpt->header->entry_lba;
+        label->gpt->header->entry_lba = host2uint64_t_le(n_blocks - 
+            (uint32_t_le2host(label->gpt->header->fillries) * sizeof(gpt_entry_t)) 
+            / b_size - 1);
+        
+        label->gpt->header->header_crc32 = 0;
+        label->gpt->header->header_crc32 = host2uint32_t_le( 
+            compute_crc32((uint8_t *) label->gpt->header,
+                uint32_t_le2host(label->gpt->header->header_size)));
+        
         /* Write to backup GPT header location */
-        //FIXME: those idiots thought it would be cool to have these fields in reverse order...
         rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, label->gpt->header);
+        if (rc != EOK) {
+                block_fini(dev_handle);
+                return rc;
+        }
+        
+        
+        /* Prepare the main header */
+        label->gpt->header->entry_lba = tmp;
+        
+        tmp = label->gpt->header->alternate_lba;
+        label->gpt->header->alternate_lba = label->gpt->header->my_lba;
+        label->gpt->header->my_lba = tmp;
+        
+        label->gpt->header->header_crc32 = 0;
+        label->gpt->header->header_crc32 = host2uint32_t_le( 
+            compute_crc32((uint8_t *) label->gpt->header,
+                uint32_t_le2host(label->gpt->header->header_size)));
+        
+        /* Write to main GPT header location */
+        rc = block_write_direct(dev_handle, GPT_HDR_BA, GPT_HDR_BS, label->gpt->header);
         block_fini(dev_handle);
         if (rc != EOK)
                 return rc;
-
+        
+        
         return 0;
 }
@@ -218 +252 @@
 gpt_partitions_t * gpt_alloc_partitions()
 {
-        return alloc_part_array(128);
+        return alloc_part_array(GPT_MIN_PART_NUM);
 }
 
@@ -230 +264 @@
         int rc;
         unsigned int i;
-        uint32_t fill = uint32_t_le2host(label->gpt->header->fillries);
+        uint32_t fillries = uint32_t_le2host(label->gpt->header->fillries);
         uint32_t ent_size = uint32_t_le2host(label->gpt->header->entry_size);
         uint64_t ent_lba = uint64_t_le2host(label->gpt->header->entry_lba);
         
         if (label->parts == NULL) {
-                label->parts = alloc_part_array(fill);
+                label->parts = alloc_part_array(fillries);
                 if (label->parts == NULL) {
                         return ENOMEM;
@@ -241 +275 @@
         }
 
-        /* We can limit comm_size like this:
-         *  - we don't need more bytes
-         *  - the size of GPT partition entry can be different to 128 bytes */
         /* comm_size is ignored */
         rc = block_init(EXCHANGE_SERIALIZE, label->device, sizeof(gpt_entry_t));
@@ -258 +289 @@
         aoff64_t pos = ent_lba * block_size;
 
-        /* Now we read just sizeof(gpt_entry_t) bytes for each entry from the device.
+        /* 
+         * Now we read just sizeof(gpt_entry_t) bytes for each entry from the device.
          * Hopefully, this does not bypass cache (no mention in libblock.c),
          * and also allows us to have variable partition entry size (but we
          * will always read just sizeof(gpt_entry_t) bytes - hopefully they
-         * don't break backward compatibility) */
-        for (i = 0; i < fill; ++i) {
-                //FIXME: this does bypass cache...
+         * don't break backward compatibility) 
+         */
+        for (i = 0; i < fillries; ++i) {
+                /*FIXME: this does bypass cache... */
                 rc = block_read_bytes_direct(label->device, pos, sizeof(gpt_entry_t), label->parts->part_array + i);
-                //FIXME: but seqread() is just too complex...
-                //rc = block_seqread(gpt->device, &bufpos, &buflen, &pos, res->part_array[i], sizeof(gpt_entry_t));
+                /* 
+                 * FIXME: but seqread() is just too complex...
+                 * rc = block_seqread(gpt->device, &bufpos, &buflen, &pos, res->part_array[i], sizeof(gpt_entry_t));
+                 */
                 pos += ent_size;
 
@@ -274 +309 @@
         }
 
-        /* FIXME: so far my boasting about variable partition entry size
+        /*
+         * FIXME: so far my boasting about variable partition entry size
          * will not work. The CRC32 checksums will be different.
          * This can't be fixed easily - we'd have to run the checksum
@@ -280 +316 @@
          */
         uint32_t crc = compute_crc32((uint8_t *) label->parts->part_array, 
-                           label->parts->fill * sizeof(gpt_entry_t));
+                           fillries * sizeof(gpt_entry_t));
 
         if(uint32_t_le2host(label->gpt->header->pe_array_crc32) != crc)
@@ -312 +348 @@
         size_t b_size;
         uint32_t e_size = uint32_t_le2host(label->gpt->header->entry_size);
-        size_t fill = label->parts->fill > GPT_MIN_PART_NUM ? label->parts->fill : GPT_MIN_PART_NUM;
-        
-        label->gpt->header->pe_array_crc32 = compute_crc32(
+        size_t fillries = label->parts->fill > GPT_MIN_PART_NUM ? label->parts->fill : GPT_MIN_PART_NUM;
+        
+        label->gpt->header->fillries = host2uint32_t_le(fillries);
+        label->gpt->header->pe_array_crc32 = host2uint32_t_le(compute_crc32(
                                        (uint8_t *) label->parts->part_array,
-                                       fill * e_size);
+                                       fillries * e_size));
         
         /* comm_size of 4096 is ignored */
@@ -332 +369 @@
                 goto fail;
         
+        uint64_t arr_blocks = (fillries * sizeof(gpt_entry_t)) / b_size;
+        label->gpt->header->first_usable_lba = host2uint64_t_le(arr_blocks + 1);
+        label->gpt->header->last_usable_lba = host2uint64_t_le(n_blocks - arr_blocks - 2);
+        
+        
         /* Write to backup GPT partition array location */
-        //rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, header->raw_data);
+        rc = block_write_direct(dev_handle, n_blocks - arr_blocks - 1, 
+                 arr_blocks, label->parts->part_array);
         if (rc != EOK)
                 goto fail;
@@ -339 +382 @@
         /* Write to main GPT partition array location */
         rc = block_write_direct(dev_handle, uint64_t_le2host(label->gpt->header->entry_lba),
-                        nearest_larger_int((uint64_t_le2host(label->gpt->header->entry_size) * label->parts->fill) / b_size),
-                        label->parts->part_array);
+                 arr_blocks, label->parts->part_array);
         if (rc != EOK)
                 goto fail;
@@ -385 +427 @@
 {
         gpt_part_t *p;
+        
         
         /* Find the first empty entry */
@@ -440 +483 @@
 int gpt_add_partition(gpt_label_t *label, gpt_part_t *partition)
 {
-        if (label->parts->fill == label->parts->arr_size) {
-                if (extend_part_array(label->parts) == -1)
-                        return ENOMEM;
-        }
-        
-        /*FIXME:
-         * Check dimensions and stuff! */
+        /* FIXME: Check dimensions! */
         gpt_part_foreach(label, p) {
                 if (gpt_get_part_type(p) != GPT_PTE_UNUSED) {
@@ -454 +491 @@
         }
         
-        memcpy(label->parts->part_array + label->parts->fill++,
-               partition, sizeof(gpt_part_t));
-        
+        gpt_part_t *p;
+        /* Find the first empty entry */
+        do {
+                if (label->parts->fill == label->parts->arr_size) {
+                        if (extend_part_array(label->parts) == -1)
+                                return ENOMEM;
+                }
+                
+                p = label->parts->part_array + label->parts->fill++;
+                
+        } while (gpt_get_part_type(p) != GPT_PTE_UNUSED);
+        
+        
+        memcpy(p, partition, sizeof(gpt_entry_t));
         
         
@@ -473 +521 @@
 int gpt_remove_partition(gpt_label_t *label, size_t idx)
 {
-        if (idx >= label->parts->fill)
+        if (idx >= label->parts->arr_size)
                 return EINVAL;
         
-        /* FIXME! 
+        /* 
+         * FIXME! 
          * If we allow blank spots, we break the array. If we have more than
          * 128 partitions in the array and then remove something from
-         * the first 128 partitions, we would forget to write the last one.*/
+         * the first 128 partitions, we would forget to write the last one.
+         */
         memset(label->parts->part_array + idx, 0, sizeof(gpt_entry_t));
         
-        label->parts->fill -= 1;
-        
-        /* FIXME! HOPEFULLY FIXED.
+        if (label->parts->fill > idx)
+                label->parts->fill = idx;
+        
+        /* 
+         * FIXME! HOPEFULLY FIXED.
          * We cannot reduce the array so simply. We may have some partitions
-         * there since we allow blank spots. */
+         * there since we allow blank spots. 
+         */
         gpt_part_t * p;
-        if (label->parts->fill < (label->parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
+        
+        if (label->parts->fill > GPT_MIN_PART_NUM &&
+            label->parts->fill < (label->parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
                 for (p = gpt_get_partition_at(label, label->parts->arr_size / 2); 
                      p < label->parts->part_array + label->parts->arr_size; ++p) {
@@ -633 +688 @@
 }
 
-// Internal functions follow //
+/** Generate a new pseudo-random UUID
+ * @param uuid Pointer to the UUID to overwrite.
+ */
+void gpt_set_random_uuid(uint8_t * uuid)
+{
+        srandom((unsigned int) uuid);
+        
+        unsigned int i;
+        for (i = 0; i < 16/sizeof(long int); ++i)
+                ((long int *)uuid)[i] = random();
+        
+}
+
+/** Get next aligned address */
+uint64_t gpt_get_next_aligned(uint64_t addr, unsigned int alignment)
+{
+        uint64_t div = addr / alignment;
+        return (div + 1) * alignment;
+}
+
+/* Internal functions follow */
 
 static int load_and_check_header(service_id_t dev_handle, aoff64_t addr, size_t b_size, gpt_header_t * header)
@@ -674 +749 @@
                 return NULL;
         }
-
+        
         uint32_t size = num > GPT_BASE_PART_NUM ? num : GPT_BASE_PART_NUM;
         res->part_array = malloc(size * sizeof(gpt_entry_t));
@@ -682 +757 @@
                 return NULL;
         }
-
-        res->fill = num;
-        res->arr_size = size;
+        
+        memset(res->part_array, 0, size * sizeof(gpt_entry_t));
+        
+        res->fill = 0;
+        res->arr_size = num;
 
         return res;
@@ -691 +768 @@
 static int extend_part_array(gpt_partitions_t * p)
 {
-        unsigned int nsize = p->arr_size * 2;
+        size_t nsize = p->arr_size * 2;
         gpt_entry_t * tmp = malloc(nsize * sizeof(gpt_entry_t));
         if(tmp == NULL) {
@@ -697 +774 @@
                 return -1;
         }
-
-        memcpy(tmp, p->part_array, p->fill);
+        
+        memcpy(tmp, p->part_array, p->fill * sizeof(gpt_entry_t));
         free(p->part_array);
         p->part_array = tmp;
@@ -715 +792 @@
                         return ENOMEM;
 
-                memcpy(tmp, p->part_array, p->fill < nsize ? p->fill  : nsize);
+                memcpy(tmp, p->part_array, p->fill < nsize ? p->fill : nsize);
                 free(p->part_array);
                 p->part_array = tmp;
@@ -724 +801 @@
 }
 
-//FIXME: replace this with a library call, if it exists
-static long long nearest_larger_int(double a)
+/*static long long nearest_larger_int(double a)
 {
         if ((long long) a == a) {
@@ -732 +808 @@
 
         return ((long long) a) + 1;
-}
-
+}*/
+
+/* Parse a byte from a string in hexadecimal 
+ * i.e., "FF" => 255 
+ */
 static uint8_t get_byte(const char * c)
 {
@@ -743 +822 @@
 }
 
-static int check_overlap(gpt_part_t * p1, gpt_part_t * p2)
+static bool check_overlap(gpt_part_t * p1, gpt_part_t * p2)
 {
         if (gpt_get_start_lba(p1) < gpt_get_start_lba(p2) && gpt_get_end_lba(p1) <= gpt_get_start_lba(p2)) {
-                return 0;
+                return false;
         } else if (gpt_get_start_lba(p1) > gpt_get_start_lba(p2) && gpt_get_end_lba(p2) <= gpt_get_start_lba(p1)) {
-                return 0;
-        }
-
-        return 1;
-}
-
-
+                return false;
+        }
+
+        return true;
+}
+
+

uspace/lib/gpt/libgpt.h

@@ -34 +34 @@
  */
 
-#ifndef __GPT_H__
-#define __GPT_H__
+#ifndef LIBGPT_LIBGPT_H_
+#define LIBGPT_LIBGPT_H_
 
 #define LIBGPT_NAME     "libgpt"
@@ -41 +41 @@
 #include <loc.h>
 #include <sys/types.h>
+
+#include "gpt.h"
 
 /** Block address of GPT header. */
@@ -59 +61 @@
 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
- * - all in little endian.
- */
-typedef struct {
-        uint8_t  efi_signature[8];
-        uint32_t revision;
-        uint32_t header_size;
-        uint32_t header_crc32;
-        uint32_t reserved;
-        uint64_t my_lba;
-        uint64_t alternate_lba;
-        uint64_t first_usable_lba;
-        uint64_t last_usable_lba;
-        uint8_t  disk_guid[16];
-        uint64_t entry_lba;
-        uint32_t fillries;
-        uint32_t entry_size;
-        uint32_t pe_array_crc32;
-} __attribute__((packed)) gpt_header_t;
-
 typedef struct {
         /** Raw header. Has more bytes alloced than sizeof(gpt_header_t)!
@@ -93 +67 @@
 } gpt_t;
 
-/** GPT partition entry */
-typedef struct {
-        uint8_t part_type[16];
-        uint8_t part_id[16];
-        uint64_t start_lba;
-        uint64_t end_lba;
-        uint64_t attributes;
-        uint8_t part_name[72];
-} __attribute__((packed)) gpt_entry_t;
-
-
-//typedef struct g_part {
-        ///** Partition entry is in use **/
-        //bool present;
-        ///** Address of first block */
-        //aoff64_t start_addr;
-        ///** Number of blocks */
-        //aoff64_t length;
-        ///** Raw data access */
-        //gpt_entry_t raw_data; //TODO: a pointer or just a member?
-//}gpt_part_t;
 typedef gpt_entry_t gpt_part_t;
-
 
 typedef struct gpt_parts {
@@ -167 +119 @@
 extern void            gpt_set_flag     (gpt_part_t *, GPT_ATTR, bool);
 
+extern void            gpt_set_random_uuid(uint8_t *);
+extern uint64_t        gpt_get_next_aligned(uint64_t, unsigned int);
 
 
 #define gpt_part_foreach(label, iterator) \
                 for(gpt_part_t * iterator = (label)->parts->part_array; \
-                    iterator < (label)->parts->part_array + (label)->parts->fill; ++iterator)
+                    iterator < (label)->parts->part_array + (label)->parts->arr_size; ++iterator)
 
 extern void gpt_free_gpt(gpt_t *);

uspace/lib/mbr/libmbr.c

@@ -42 +42 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <str_error.h>
 
 #include "libmbr.h"
@@ -49 +50 @@
 static int decode_logical(mbr_label_t *, mbr_part_t *);
 static void encode_part(mbr_part_t *, pt_entry_t *, uint32_t, bool);
-static int check_overlap(mbr_part_t *, mbr_part_t *);
-static int check_encaps(mbr_part_t *, mbr_part_t *);
-static int check_preceeds(mbr_part_t *, mbr_part_t *);
-static mbr_err_val mbr_add_primary(mbr_label_t *label, mbr_part_t *p);
-static mbr_err_val mbr_add_logical(mbr_label_t *label, mbr_part_t *p);
+static bool check_overlap(mbr_part_t *, mbr_part_t *);
+static bool check_encaps(mbr_part_t *, mbr_part_t *);
+static bool check_preceeds(mbr_part_t *, mbr_part_t *);
+static mbr_err_val mbr_add_primary(mbr_label_t *, mbr_part_t *);
+static mbr_err_val mbr_add_logical(mbr_label_t *, mbr_part_t *);
 
 /** Allocate and initialize mbr_label_t structure */
@@ -759 +760 @@
 /** Check whether two partitions overlap
  * 
- * @return              1 for yes, 0 for no
- */
-static int check_overlap(mbr_part_t * p1, mbr_part_t * p2)
+ * @return              true/false
+ */
+static bool 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) {
-                return 0;
+                return false;
         } else if (p1->start_addr > p2->start_addr && p2->start_addr + p2->length <= p1->start_addr) {
-                return 0;
-        }
-
-        return 1;
+                return false;
+        }
+
+        return true;
 }
 
 /** Check whether one partition encapsulates the other
  * 
- * @return              1 for yes, 0 for no
- */
-static int check_encaps(mbr_part_t * inner, mbr_part_t * outer)
+ * @return              true/false
+ */
+static bool check_encaps(mbr_part_t * inner, mbr_part_t * outer)
 {
         if (inner->start_addr <= outer->start_addr || outer->start_addr + outer->length <= inner->start_addr) {
-                return 0;
+                return false;
         } else if (outer->start_addr + outer->length < inner->start_addr + inner->length) {
-                return 0;
-        }
-
-        return 1;
+                return false;
+        }
+
+        return true;
 }
 
 /** Check whether one partition preceeds the other
  * 
- * @return              1 for yes, 0 for no
- */
-static int check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee)
+ * @return              true/false
+ */
+static bool check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee)
 {
         return preceeder->start_addr < precedee->start_addr;

uspace/lib/mbr/libmbr.h

@@ -38 +38 @@
 
 #include <sys/types.h>
+#include "mbr.h"
 
 #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 */
-#define N_PRIMARY               4
-
-/** Boot record signature */
-#define BR_SIGNATURE    0xAA55
-
-enum {
-        /** Non-bootable */
-        B_INACTIVE = 0x00,
-        /** Bootable */
-        B_ACTIVE = 0x80,
-        /** Anything else means invalid */
-};
 
 typedef enum {
@@ -80 +49 @@
         ST_LOGIC = 8
 } MBR_FLAGS;
-
-enum {
-        /** Unused partition entry */
-        PT_UNUSED       = 0x00,
-        /** Extended partition */
-        PT_EXTENDED     = 0x05,
-        /** Extended partition with LBA */
-        PT_EXTENDED_LBA = 0x0F,
-        /** GPT Protective partition */
-        PT_GPT  = 0xEE,
-};
 
 typedef enum {
@@ -112 +70 @@
         ERR_LIBBLOCK,
 } mbr_err_val;
-
-
-/** Structure of a partition table entry */
-typedef struct {
-        uint8_t status;
-        /** CHS of fist block in partition */
-        uint8_t first_chs[3];
-        /** Partition type */
-        uint8_t ptype;
-        /** CHS of last block in partition */
-        uint8_t last_chs[3];
-        /** LBA of first block in partition */
-        uint32_t first_lba;
-        /** Number of blocks in partition */
-        uint32_t length;
-} __attribute__((packed)) pt_entry_t;
-
-/** Structure of a boot-record block */
-typedef struct {
-        /** Area for boot code */
-        uint8_t code_area[440];
-        /** Optional media ID */
-        uint32_t media_id;
-        /** Padding */
-        uint16_t pad0;
-        /** Partition table entries */
-        pt_entry_t pte[N_PRIMARY];
-        /** Boot record block signature (@c BR_SIGNATURE) */
-        uint16_t signature;
-} __attribute__((packed)) br_block_t;
 
 /** MBR header */