source: mainline/uspace/lib/gpt/libgpt.c@ 8a45707d

/*
 * Copyright (c) 2011-2013 Dominik Taborsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libgpt
 * @{
 */
/** @file
 */

/* TODO:
 * The implementation currently supports fixed size partition entries only.
 * The specification requires otherwise, though.
 */

#include <ipc/bd.h>
#include <async.h>
#include <stdio.h>
#include <block.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
#include <byteorder.h>
#include <adt/checksum.h>
#include <mem.h>
#include <sys/typefmt.h>
#include <mbr.h>
#include <align.h>
#include "libgpt.h"

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 uint8_t get_byte(const char *);
static bool check_overlap(gpt_part_t *, gpt_part_t *);
static bool check_encaps(gpt_part_t *, uint64_t, uint64_t);

/** Allocate a GPT label */
gpt_label_t *gpt_alloc_label(void)
{
        gpt_label_t *label = malloc(sizeof(gpt_label_t));
        if (label == NULL)
                return NULL;
        
        label->parts = gpt_alloc_partitions();
        if (label->parts == NULL) {
                free(label);
                return NULL;
        }
        
        label->gpt = NULL;
        label->device = 0;
        
        return label;
}

/** Free a GPT label */
void gpt_free_label(gpt_label_t *label)
{
        if (label->gpt != NULL)
                gpt_free_gpt(label->gpt);
        
        if (label->parts != NULL)
                gpt_free_partitions(label->parts);
        
        free(label);
}

/** Allocate a GPT header */
gpt_t *gpt_alloc_header(size_t size)
{
        gpt_t *gpt = malloc(sizeof(gpt_t));
        if (gpt == NULL)
                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
         */
        size_t final_size = max(size, sizeof(gpt_header_t));
        gpt->header = malloc(final_size);
        if (gpt->header == NULL) {
                free(gpt);
                return NULL;
        }
        
        memset(gpt->header, 0, final_size);
        memcpy(gpt->header->efi_signature, efi_signature, 8);
        memcpy(gpt->header->revision, revision, 4);
        gpt->header->header_size = host2uint32_t_le(final_size);
        gpt->header->entry_lba = host2uint64_t_le((uint64_t) 2);
        gpt->header->entry_size = host2uint32_t_le(sizeof(gpt_entry_t));
        
        return gpt;
}

/** Free a GPT header */
void gpt_free_gpt(gpt_t *gpt)
{
        free(gpt->header);
        free(gpt);
}

/** Read GPT from a device
 *
 * @param label      Label to read.
 * @param dev_handle Device to read GPT from.
 *
 * @return EOK on success, error code on error.
 *
 */
int gpt_read_header(gpt_label_t *label, service_id_t dev_handle)
{
        int rc = block_init(dev_handle, 512);
        if (rc != EOK)
                return rc;
        
        size_t block_size;
        rc = block_get_bsize(dev_handle, &block_size);
        if (rc != EOK)
                goto end;
        
        if (label->gpt == NULL) {
                label->gpt = gpt_alloc_header(block_size);
                if (label->gpt == NULL) {
                        rc = ENOMEM;
                        goto end;
                }
        }
        
        rc = load_and_check_header(dev_handle, GPT_HDR_BA, block_size,
            label->gpt->header);
        if ((rc == EBADCHECKSUM) || (rc == EINVAL)) {
                aoff64_t blocks;
                rc = block_get_nblocks(dev_handle, &blocks);
                if (rc != EOK) {
                        gpt_free_gpt(label->gpt);
                        goto end;
                }
                
                rc = load_and_check_header(dev_handle, blocks - 1, block_size,
                    label->gpt->header);
                if ((rc == EBADCHECKSUM) || (rc == EINVAL)) {
                        gpt_free_gpt(label->gpt);
                        goto end;
                }
        }
        
        label->device = dev_handle;
        rc = EOK;
        
end:
        block_fini(dev_handle);
        return rc;
}

/** Write GPT header to device
 *
 * @param label        Label to be written.
 * @param dev_handle   Device to write the GPT to.
 *
 * @return EOK on success, libblock error code otherwise.
 *
 */
int gpt_write_header(gpt_label_t *label, service_id_t dev_handle)
{
        /* The comm_size argument (the last one) is ignored */
        int rc = block_init(dev_handle, 4096);
        if ((rc != EOK) && (rc != EEXIST))
                return rc;
        
        size_t block_size;
        rc = block_get_bsize(dev_handle, &block_size);
        if (rc != EOK)
                goto end;
        
        aoff64_t blocks;
        rc = block_get_nblocks(dev_handle, &blocks);
        if (rc != EOK)
                goto end;
        
        gpt_set_random_uuid(label->gpt->header->disk_guid);
        
        /* Prepare the backup header */
        label->gpt->header->alternate_lba = label->gpt->header->current_lba;
        label->gpt->header->current_lba = host2uint64_t_le(blocks - 1);
        
        uint64_t lba = label->gpt->header->entry_lba;
        label->gpt->header->entry_lba = host2uint64_t_le(blocks -
            (uint32_t_le2host(label->gpt->header->fillries) *
            sizeof(gpt_entry_t)) / block_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 */
        rc = block_write_direct(dev_handle, blocks - 1, GPT_HDR_BS,
            label->gpt->header);
        if (rc != EOK)
                goto end;
        
        /* Prepare the main header */
        label->gpt->header->entry_lba = lba;
        
        lba = label->gpt->header->alternate_lba;
        label->gpt->header->alternate_lba = label->gpt->header->current_lba;
        label->gpt->header->current_lba = lba;
        
        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);
        if (rc != EOK)
                goto end;
        
        /* Write Protective MBR */
        br_block_t mbr;
        memset(&mbr, 0, 512);
        
        memset(mbr.pte[0].first_chs, 1, 3);
        mbr.pte[0].ptype = 0xEE;
        memset(mbr.pte[0].last_chs, 0xff, 3);
        mbr.pte[0].first_lba = host2uint32_t_le(1);
        mbr.pte[0].length = 0xffffffff;
        mbr.signature = host2uint16_t_le(BR_SIGNATURE);
        
        rc = block_write_direct(dev_handle, 0, 1, &mbr);
        
end:
        block_fini(dev_handle);
        return rc;
}

/** Alloc partition array */
gpt_partitions_t *gpt_alloc_partitions(void)
{
        return alloc_part_array(GPT_MIN_PART_NUM);
}

/** Parse partitions from GPT
 *
 * @param label GPT label to be parsed.
 *
 * @return EOK on success, error code otherwise.
 *
 */
int gpt_read_partitions(gpt_label_t *label)
{
        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(fillries);
                if (label->parts == NULL)
                        return ENOMEM;
        }
        
        int rc = block_init(label->device, sizeof(gpt_entry_t));
        if (rc != EOK) {
                gpt_free_partitions(label->parts);
                label->parts = NULL;
                goto end;
        }
        
        size_t block_size;
        rc = block_get_bsize(label->device, &block_size);
        if (rc != EOK) {
                gpt_free_partitions(label->parts);
                label->parts = NULL;
                goto end;
        }
        
        aoff64_t pos = ent_lba * block_size;
        
        for (uint32_t i = 0; i < fillries; i++) {
                rc = block_read_bytes_direct(label->device, pos, sizeof(gpt_entry_t),
                    label->parts->part_array + i);
                pos += ent_size;
                
                if (rc != EOK) {
                        gpt_free_partitions(label->parts);
                        label->parts = NULL;
                        goto end;
                }
        }
        
        uint32_t crc = compute_crc32((uint8_t *) label->parts->part_array,
            fillries * ent_size);
        
        if (uint32_t_le2host(label->gpt->header->pe_array_crc32) != crc) {
                rc = EBADCHECKSUM;
                gpt_free_partitions(label->parts);
                label->parts = NULL;
                goto end;
        }
        
        rc = EOK;
        
end:
        block_fini(label->device);
        return rc;
}

/** Write GPT and partitions to device
 *
 * Note: Also writes the header.
 *
 * @param label      Label to write.
 * @param dev_handle Device to write the data to.
 *
 * @return EOK on succes, error code otherwise
 *
 */
int gpt_write_partitions(gpt_label_t *label, service_id_t dev_handle)
{
        /* comm_size of 4096 is ignored */
        int rc = block_init(dev_handle, 4096);
        if ((rc != EOK) && (rc != EEXIST))
                return rc;
        
        size_t block_size;
        rc = block_get_bsize(dev_handle, &block_size);
        if (rc != EOK)
                goto fail;
        
        aoff64_t blocks;
        rc = block_get_nblocks(dev_handle, &blocks);
        if (rc != EOK)
                goto fail;
        
        if (label->gpt == NULL)
                label->gpt = gpt_alloc_header(block_size);
        
        uint32_t entry_size =
            uint32_t_le2host(label->gpt->header->entry_size);
        size_t fillries = (label->parts->fill > GPT_MIN_PART_NUM) ?
            label->parts->fill : GPT_MIN_PART_NUM;
        
        if (entry_size != sizeof(gpt_entry_t))
                return ENOTSUP;
        
        label->gpt->header->fillries = host2uint32_t_le(fillries);
        
        uint64_t arr_blocks = (fillries * sizeof(gpt_entry_t)) / block_size;
        
        /* Include Protective MBR */
        uint64_t gpt_space = arr_blocks + GPT_HDR_BS + 1;
        
        label->gpt->header->first_usable_lba = host2uint64_t_le(gpt_space);
        label->gpt->header->last_usable_lba =
            host2uint64_t_le(blocks - gpt_space - 1);
        
        /* Perform checks */
        gpt_part_foreach (label, p) {
                if (gpt_get_part_type(p) == GPT_PTE_UNUSED)
                        continue;
                
                if (!check_encaps(p, blocks, gpt_space)) {
                        rc = ERANGE;
                        goto fail;
                }
                
                gpt_part_foreach (label, q) {
                        if (p == q)
                                continue;
                        
                        if (gpt_get_part_type(p) != GPT_PTE_UNUSED) {
                                if (check_overlap(p, q)) {
                                        rc = ERANGE;
                                        goto fail;
                                }
                        }
                }
        }
        
        label->gpt->header->pe_array_crc32 =
            host2uint32_t_le(compute_crc32((uint8_t *) label->parts->part_array,
            fillries * entry_size));
        
        /* Write to backup GPT partition array location */
        rc = block_write_direct(dev_handle, blocks - arr_blocks - 1,
            arr_blocks, label->parts->part_array);
        if (rc != EOK)
                goto fail;
        
        /* Write to main GPT partition array location */
        rc = block_write_direct(dev_handle,
            uint64_t_le2host(label->gpt->header->entry_lba),
            arr_blocks, label->parts->part_array);
        if (rc != EOK)
                goto fail;
        
        return gpt_write_header(label, dev_handle);
        
fail:
        block_fini(dev_handle);
        return rc;
}

/** Allocate a new partition
 *
 * Note: Use either gpt_alloc_partition() or gpt_get_partition().
 * This returns a memory block (zero-filled) and needs gpt_add_partition()
 * to be called to insert it into a partition array.
 * Requires you to call gpt_free_partition afterwards.
 *
 * @return Pointer to the new partition or NULL.
 *
 */
gpt_part_t *gpt_alloc_partition(void)
{
        gpt_part_t *partition = malloc(sizeof(gpt_part_t));
        if (partition == NULL)
                return NULL;
        
        memset(partition, 0, sizeof(gpt_part_t));
        
        return partition;
}

/** Allocate a new partition already inside the label
 *
 * Note: Use either gpt_alloc_partition() or gpt_get_partition().
 * This one returns a pointer to the first empty structure already
 * inside the array, so don't call gpt_add_partition() afterwards.
 * This is the one you will usually want.
 *
 * @param label Label to carry new partition.
 *
 * @return Pointer to the new partition or NULL.
 *
 */
gpt_part_t *gpt_get_partition(gpt_label_t *label)
{
        gpt_part_t *partition;
        
        /* Find the first empty entry */
        do {
                if (label->parts->fill == label->parts->arr_size) {
                        if (extend_part_array(label->parts) == -1)
                                return NULL;
                }
                
                partition = label->parts->part_array + label->parts->fill++;
        } while (gpt_get_part_type(partition) != GPT_PTE_UNUSED);
        
        return partition;
}

/** Get partition already inside the label
 *
 * Note: For new partitions use either gpt_alloc_partition() or
 * gpt_get_partition() unless you want a partition at a specific place.
 * This returns a pointer to a structure already inside the array,
 * so don't call gpt_add_partition() afterwards.
 * This function is handy when you want to change already existing
 * partition or to simply write somewhere in the middle. This works only
 * for indexes smaller than either 128 or the actual number of filled
 * entries.
 *
 * @param label Label to carrying the partition.
 * @param idx   Index of the partition.
 *
 * @return Pointer to the partition or NULL when out of range.
 *
 */
gpt_part_t *gpt_get_partition_at(gpt_label_t *label, size_t idx)
{
        if ((idx >= GPT_MIN_PART_NUM) && (idx >= label->parts->fill))
                return NULL;
        
        return label->parts->part_array + idx;
}

/** Copy partition into partition array
 *
 * Note: For use with gpt_alloc_partition() only. You will get
 * duplicates with gpt_get_partition().
 * Note: Does not call gpt_free_partition()!
 *
 * @param parts     Target label
 * @param partition Source partition to copy
 *
 * @return EOK on succes, error code otherwise
 *
 */
int gpt_add_partition(gpt_label_t *label, gpt_part_t *partition)
{
        /* Find the first empty entry */
        
        gpt_part_t *part;
        
        do {
                if (label->parts->fill == label->parts->arr_size) {
                        if (extend_part_array(label->parts) == -1)
                                return ENOMEM;
                }
                
                part = label->parts->part_array + label->parts->fill++;
        } while (gpt_get_part_type(part) != GPT_PTE_UNUSED);
        
        memcpy(part, partition, sizeof(gpt_entry_t));
        return EOK;
}

/** Remove partition from array
 *
 * Note: Even if it fails, the partition still gets removed. Only
 * reducing the array failed.
 *
 * @param label Label to remove from
 * @param idx   Index of the partition to remove
 *
 * @return EOK on success, ENOMEM on array reduction failure
 *
 */
int gpt_remove_partition(gpt_label_t *label, size_t idx)
{
        if (idx >= label->parts->arr_size)
                return EINVAL;
        
        /*
         * 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.
         */
        
        memset(label->parts->part_array + idx, 0, sizeof(gpt_entry_t));
        
        if (label->parts->fill > idx)
                label->parts->fill = idx;
        
        gpt_part_t *partition;
        
        if ((label->parts->fill > GPT_MIN_PART_NUM) &&
            (label->parts->fill < (label->parts->arr_size / 2) -
            GPT_IGNORE_FILL_NUM)) {
                for (partition = gpt_get_partition_at(label, label->parts->arr_size / 2);
                     partition < label->parts->part_array + label->parts->arr_size;
                     partition++) {
                        if (gpt_get_part_type(partition) != GPT_PTE_UNUSED)
                                return EOK;
                }
                
                if (reduce_part_array(label->parts) == ENOMEM)
                        return ENOMEM;
        }
        
        return EOK;
}

/** Free partition list
 *
 * @param parts Partition list to be freed
 *
 */
void gpt_free_partitions(gpt_partitions_t *parts)
{
        free(parts->part_array);
        free(parts);
}

/** Get partition type */
size_t gpt_get_part_type(gpt_part_t *partition)
{
        size_t i;
        
        for (i = 0; gpt_ptypes[i].guid != NULL; i++) {
                if ((partition->part_type[3] == get_byte(gpt_ptypes[i].guid + 0)) &&
                    (partition->part_type[2] == get_byte(gpt_ptypes[i].guid + 2)) &&
                    (partition->part_type[1] == get_byte(gpt_ptypes[i].guid + 4)) &&
                    (partition->part_type[0] == get_byte(gpt_ptypes[i].guid + 6)) &&
                    (partition->part_type[5] == get_byte(gpt_ptypes[i].guid + 8)) &&
                    (partition->part_type[4] == get_byte(gpt_ptypes[i].guid + 10)) &&
                    (partition->part_type[7] == get_byte(gpt_ptypes[i].guid + 12)) &&
                    (partition->part_type[6] == get_byte(gpt_ptypes[i].guid + 14)) &&
                    (partition->part_type[8] == get_byte(gpt_ptypes[i].guid + 16)) &&
                    (partition->part_type[9] == get_byte(gpt_ptypes[i].guid + 18)) &&
                    (partition->part_type[10] == get_byte(gpt_ptypes[i].guid + 20)) &&
                    (partition->part_type[11] == get_byte(gpt_ptypes[i].guid + 22)) &&
                    (partition->part_type[12] == get_byte(gpt_ptypes[i].guid + 24)) &&
                    (partition->part_type[13] == get_byte(gpt_ptypes[i].guid + 26)) &&
                    (partition->part_type[14] == get_byte(gpt_ptypes[i].guid + 28)) &&
                    (partition->part_type[15] == get_byte(gpt_ptypes[i].guid + 30)))
                        return i;
        }
        
        return i;
}

/** Set partition type */
void gpt_set_part_type(gpt_part_t *partition, size_t type)
{
        /* Beware: first 3 blocks are byteswapped! */
        partition->part_type[3] = get_byte(gpt_ptypes[type].guid + 0);
        partition->part_type[2] = get_byte(gpt_ptypes[type].guid + 2);
        partition->part_type[1] = get_byte(gpt_ptypes[type].guid + 4);
        partition->part_type[0] = get_byte(gpt_ptypes[type].guid + 6);
        
        partition->part_type[5] = get_byte(gpt_ptypes[type].guid + 8);
        partition->part_type[4] = get_byte(gpt_ptypes[type].guid + 10);
        
        partition->part_type[7] = get_byte(gpt_ptypes[type].guid + 12);
        partition->part_type[6] = get_byte(gpt_ptypes[type].guid + 14);
        
        partition->part_type[8] = get_byte(gpt_ptypes[type].guid + 16);
        partition->part_type[9] = get_byte(gpt_ptypes[type].guid + 18);
        partition->part_type[10] = get_byte(gpt_ptypes[type].guid + 20);
        partition->part_type[11] = get_byte(gpt_ptypes[type].guid + 22);
        partition->part_type[12] = get_byte(gpt_ptypes[type].guid + 24);
        partition->part_type[13] = get_byte(gpt_ptypes[type].guid + 26);
        partition->part_type[14] = get_byte(gpt_ptypes[type].guid + 28);
        partition->part_type[15] = get_byte(gpt_ptypes[type].guid + 30);
}

/** Get partition starting LBA */
uint64_t gpt_get_start_lba(gpt_part_t *partition)
{
        return uint64_t_le2host(partition->start_lba);
}

/** Set partition starting LBA */
void gpt_set_start_lba(gpt_part_t *partition, uint64_t start)
{
        partition->start_lba = host2uint64_t_le(start);
}

/** Get partition ending LBA */
uint64_t gpt_get_end_lba(gpt_part_t *partition)
{
        return uint64_t_le2host(partition->end_lba);
}

/** Set partition ending LBA */
void gpt_set_end_lba(gpt_part_t *partition, uint64_t end)
{
        partition->end_lba = host2uint64_t_le(end);
}

/** Get partition name */
unsigned char * gpt_get_part_name(gpt_part_t *partition)
{
        return partition->part_name;
}

/** Copy partition name */
void gpt_set_part_name(gpt_part_t *partition, char *name, size_t length)
{
        if (length >= 72)
                length = 71;
        
        memcpy(partition->part_name, name, length);
        partition->part_name[length] = '\0';
}

/** Get partition attribute */
bool gpt_get_flag(gpt_part_t *partition, gpt_attr_t flag)
{
        return (partition->attributes & (((uint64_t) 1) << flag)) ? 1 : 0;
}

/** Set partition attribute */
void gpt_set_flag(gpt_part_t *partition, gpt_attr_t flag, bool value)
{
        uint64_t attr = partition->attributes;
        
        if (value)
                attr = attr | (((uint64_t) 1) << flag);
        else
                attr = attr ^ (attr & (((uint64_t) 1) << flag));
        
        partition->attributes = attr;
}

/** Generate a new pseudo-random UUID compliant with RFC 4122 */
void gpt_set_random_uuid(uint8_t *uuid)
{
        srandom((unsigned int) (size_t) uuid);
        
        for (size_t i = 0; i < 16; i++)
                uuid[i] = random();

        /* 
         * Set version (stored in bits 4-7 of seventh byte) to 4 (random
         * UUID) and bits 6 and 7 of ninth byte to 0 and 1 respectively -
         * according to RFC 4122, section 4.4.
         */
        uuid[6] &= 0x0f;
        uuid[6] |= (0x4 << 4);
        uuid[8] &= 0x3f;
        uuid[8] |= (1 << 7);
}

/** Get next aligned address */
uint64_t gpt_get_next_aligned(uint64_t addr, unsigned int alignment)
{
        return ALIGN_UP(addr + 1, alignment);
}

static int load_and_check_header(service_id_t dev_handle, aoff64_t addr,
    size_t block_size, gpt_header_t *header)
{
        int rc = block_read_direct(dev_handle, addr, GPT_HDR_BS, header);
        if (rc != EOK)
                return rc;
        
        /* Check the EFI signature */
        for (unsigned int i = 0; i < 8; i++) {
                if (header->efi_signature[i] != efi_signature[i])
                        return EINVAL;
        }
        
        /* Check the CRC32 of the header */
        uint32_t crc = header->header_crc32;
        header->header_crc32 = 0;
        
        if (crc != compute_crc32((uint8_t *) header, header->header_size))
                return EBADCHECKSUM;
        else
                header->header_crc32 = crc;
        
        /* Check for zeroes in the rest of the block */
        for (size_t i = sizeof(gpt_header_t); i < block_size; i++) {
                if (((uint8_t *) header)[i] != 0)
                        return EINVAL;
        }
        
        return EOK;
}

static gpt_partitions_t *alloc_part_array(uint32_t num)
{
        gpt_partitions_t *res = malloc(sizeof(gpt_partitions_t));
        if (res == NULL)
                return NULL;
        
        uint32_t size = num > GPT_BASE_PART_NUM ? num : GPT_BASE_PART_NUM;
        res->part_array = malloc(size * sizeof(gpt_entry_t));
        if (res->part_array == NULL) {
                free(res);
                return NULL;
        }
        
        memset(res->part_array, 0, size * sizeof(gpt_entry_t));
        
        res->fill = 0;
        res->arr_size = num;
        
        return res;
}

static int extend_part_array(gpt_partitions_t *partition)
{
        size_t nsize = partition->arr_size * 2;
        gpt_entry_t *entry = malloc(nsize * sizeof(gpt_entry_t));
        if (entry == NULL)
                return ENOMEM;
        
        memcpy(entry, partition->part_array, partition->fill *
            sizeof(gpt_entry_t));
        free(partition->part_array);
        
        partition->part_array = entry;
        partition->arr_size = nsize;
        
        return EOK;
}

static int reduce_part_array(gpt_partitions_t *partition)
{
        if (partition->arr_size > GPT_MIN_PART_NUM) {
                unsigned int nsize = partition->arr_size / 2;
                nsize = nsize > GPT_MIN_PART_NUM ? nsize : GPT_MIN_PART_NUM;
                
                gpt_entry_t *entry = malloc(nsize * sizeof(gpt_entry_t));
                if (entry == NULL)
                        return ENOMEM;
                
                memcpy(entry, partition->part_array,
                    partition->fill < nsize ? partition->fill : nsize);
                free(partition->part_array);
                
                partition->part_array = entry;
                partition->arr_size = nsize;
        }
        
        return EOK;
}

/* Parse a byte from a string in hexadecimal */
static uint8_t get_byte(const char *c)
{
        uint8_t val = 0;
        char hex[3] = {*c, *(c + 1), 0};
        
        str_uint8_t(hex, NULL, 16, false, &val);
        return val;
}

static bool check_overlap(gpt_part_t *part1, gpt_part_t *part2)
{
        if ((gpt_get_start_lba(part1) < gpt_get_start_lba(part2)) &&
            (gpt_get_end_lba(part1) < gpt_get_start_lba(part2)))
                return false;
        
        if ((gpt_get_start_lba(part1) > gpt_get_start_lba(part2)) &&
            (gpt_get_end_lba(part2) < gpt_get_start_lba(part1)))
                return false;
        
        return true;
}

static bool check_encaps(gpt_part_t *part, uint64_t blocks,
    uint64_t first_lba)
{
        /*
         * We allow "<=" in the second expression because it lacks
         * MBR so it is smaller by 1 block.
         */
        if ((gpt_get_start_lba(part) >= first_lba) &&
            (gpt_get_end_lba(part) <= blocks - first_lba))
                return true;
        
        return false;
}