Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 1c8bfe8 in mainline


Ignore:
Timestamp:
2013-06-25T00:27:47Z (7 years ago)
Author:
Dominik Taborsky (AT DOT) <brembyseznamcz>
Branches:
master
Children:
6317b33, 9256d093
Parents:
6e8e4e19 (diff), cb328ab (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:

GPT updates

Location:
uspace
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/hdisk/func_gpt.c

    r6e8e4e19 r1c8bfe8  
    3434
    3535#include <stdio.h>
     36#include <str.h>
    3637#include <errno.h>
    3738#include <str_error.h>
     
    6061}
    6162
    62 int add_gpt_part(label_t *this, tinput_t * in)
    63 {
    64         gpt_part_t * p = gpt_alloc_partition(this->data.gpt->parts);
     63int add_gpt_part(label_t *this, tinput_t *in)
     64{
     65        gpt_part_t * p = gpt_get_partition(this->data.gpt);
    6566        if (p == NULL) {
    6667                return ENOMEM;
    6768        }
    68 
     69       
    6970        return set_gpt_partition(in, p);
    7071}
    7172
    72 int delete_gpt_part(label_t *this, tinput_t * in)
    73 {
     73int delete_gpt_part(label_t *this, tinput_t *in)
     74{
     75        int rc;
    7476        size_t idx;
    75 
     77       
    7678        printf("Number of the partition to delete (counted from 0): ");
    7779        idx = get_input_size_t(in);
    78 
    79         if (gpt_remove_partition(this->data.gpt->parts, idx) == -1) {
     80       
     81        rc = gpt_remove_partition(this->data.gpt, idx);
     82        if (rc != EOK) {
    8083                printf("Warning: running low on memory, not resizing...\n");
    81         }
    82 
     84                return rc;
     85        }
     86       
    8387        return EOK;
    8488}
     
    8690int destroy_gpt_label(label_t *this)
    8791{
     92        gpt_free_label(this->data.gpt);
    8893        return EOK;
    8994}
     
    9196int new_gpt_label(label_t *this)
    9297{
    93         this->data.gpt->gpt = gpt_alloc_gpt_header();
    94         this->data.gpt->parts = gpt_alloc_partitions();
     98        this->data.gpt = gpt_alloc_label();
    9599        return EOK;
    96100}
     
    104108        size_t i = 0;
    105109       
    106         gpt_part_foreach(this->data.gpt->parts, iter) {
     110        gpt_part_foreach(this->data.gpt, iter) {
     111                i++;
    107112                //FIXMEE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    108                 if (gpt_get_part_type(iter) == 62)
     113                if (gpt_get_part_type(iter) == GPT_PTE_UNUSED)
    109114                        continue;
     115               
     116                if (i % 20 == 0)
     117                        printf("%15s %10s %10s Type: Name:\n", "Start:", "End:", "Length:");
    110118               
    111119                //printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
    112120                //              iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
    113                 printf("%3u\t%10llu %10llu %10llu %3d %s\n", i, gpt_get_start_lba(iter), gpt_get_end_lba(iter),
     121                printf("%3u  %10llu %10llu %10llu    %3d %s\n", i-1, gpt_get_start_lba(iter), gpt_get_end_lba(iter),
    114122                                gpt_get_end_lba(iter) - gpt_get_start_lba(iter), gpt_get_part_type(iter),
    115123                                gpt_get_part_name(iter));
    116                 i++;
    117         }
    118 
     124        }
     125       
    119126        //return rc;
    120127        return EOK;
     
    123130int read_gpt_parts(label_t *this, service_id_t dev_handle)
    124131{
     132        int rc;
     133       
     134        rc = gpt_read_header(this->data.gpt, dev_handle);
     135        if (rc != EOK) {
     136                printf("Error: Reading header failed: %d (%s)\n", rc, str_error(rc));
     137                return rc;
     138        }
     139       
     140        rc = gpt_read_partitions(this->data.gpt);
     141        if (rc != EOK) {
     142                printf("Error: Reading partitions failed: %d (%s)\n", rc, str_error(rc));
     143                return rc;
     144        }
     145       
    125146        return EOK;
    126147}
     
    129150{
    130151        int rc;
    131 
    132         rc = gpt_write_partitions(this->data.gpt->parts, this->data.gpt->gpt, dev_handle);
     152       
     153        rc = gpt_write_partitions(this->data.gpt, dev_handle);
    133154        if (rc != EOK) {
    134155                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    135156                return rc;
    136157        }
    137 
    138         rc = gpt_write_gpt_header(this->data.gpt->gpt, dev_handle);
    139         if (rc != EOK) {
    140                 printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    141                 return rc;
    142         }
    143 
    144         return EOK;
    145 }
    146 
    147 int extra_gpt_funcs(label_t *this, tinput_t * in, service_id_t dev_handle)
     158       
     159        rc = gpt_write_header(this->data.gpt, dev_handle);
     160        if (rc != EOK) {
     161                printf("Error: Writing header failed: %d (%s)\n", rc, str_error(rc));
     162                return rc;
     163        }
     164       
     165        return EOK;
     166}
     167
     168int extra_gpt_funcs(label_t *this, tinput_t *in, service_id_t dev_handle)
    148169{
    149170        printf("Not implemented.\n");
     
    151172}
    152173
    153 static int set_gpt_partition(tinput_t * in, gpt_part_t * p)
    154 {
    155         //int rc;
    156 
     174static int set_gpt_partition(tinput_t *in, gpt_part_t *p)
     175{
     176        int rc;
     177       
    157178        uint64_t sa, ea;
    158 
     179       
    159180        printf("Set starting address (number): ");
    160181        sa = get_input_uint64(in);
    161 
     182       
    162183        printf("Set end addres (number): ");
    163184        ea = get_input_uint64(in);
    164 
     185       
    165186        if (ea <= sa) {
    166187                printf("Invalid value.\n");
    167188                return EINVAL;
    168189        }
    169 
    170 
    171         //p->start_addr = sa;
     190       
    172191        gpt_set_start_lba(p, sa);
    173         //p->length = ea - sa;
    174192        gpt_set_end_lba(p, ea);
    175 
    176         return EOK;
    177 }
    178 
     193       
     194       
     195        char *name;
     196        rc = get_input_line(in, &name);
     197        if (rc != EOK) {
     198                printf("Error reading name: %d (%s)\n", rc, str_error(rc));
     199                return rc;
     200        }
     201       
     202        gpt_set_part_name(p, name, str_size(name));
     203       
     204        return EOK;
     205}
     206
  • uspace/lib/gpt/global.c

    r6e8e4e19 r1c8bfe8  
    4141
    4242const struct partition_type gpt_ptypes[] = {
    43         { "Unused entry",                                       "00000000-0000-0000-0000-000000000000" },
    44         { "MBR partition scheme",                       "024DEE41-33E7-11D3-9D69-0008C781F39F" },
    45         { "EFI System",                                         "C12A7328-F81F-11D2-BA4B-00A0C93EC93B" },
    46         { "BIOS Boot",                                          "21686148-6449-6E6F-744E-656564454649" },
    47         { "Windows Reserved",                           "E3C9E316-0B5C-4DB8-817D-F92DF00215AE" },
    48         { "Windows Basic data",                         "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7" },
    49         { "Windows LDM metadata",                       "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3" },
    50         { "Windows LDM data",                           "AF9B60A0-1431-4F62-BC68-3311714A69AD" },
    51         { "Windows Recovery Environment",       "DE94BBA4-06D1-4D40-A16A-BFD50179D6AC" },
    52         { "Windows IBM GPFS",                           "37AFFC90-EF7D-4E96-91C3-2D7AE055B174" },
    53         { "Windows Cluster metadata",           "DB97DBA9-0840-4BAE-97F0-FFB9A327C7E1" },
    54         { "HP-UX Data",                                         "75894C1E-3AEB-11D3-B7C1-7B03A0000000" },
    55         { "HP-UX Service",                                      "E2A1E728-32E3-11D6-A682-7B03A0000000" },
    56         { "Linux filesystem data",                      "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7" },
    57         { "Linux filesystem data",                      "0FC63DAF-8483-4772-8E79-3D69D8477DE4" },
    58         { "Linux RAID",                                         "A19D880F-05FC-4D3B-A006-743F0F84911E" },
    59         { "Linux Swap",                                         "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F" },
    60         { "Linux LVM",                                          "E6D6D379-F507-44C2-A23C-238F2A3DF928" },
    61         { "Linux Reserved",                                     "8DA63339-0007-60C0-C436-083AC8230908" },
    62         { "FreeBSD Boot",                                       "83BD6B9D-7F41-11DC-BE0B-001560B84F0F" },
    63         { "FreeBSD Data",                                       "516E7CB4-6ECF-11D6-8FF8-00022D09712B" },
    64         { "FreeBSD Swap",                                       "516E7CB5-6ECF-11D6-8FF8-00022D09712B" },
    65         { "FreeBSD UFS",                                        "516E7CB6-6ECF-11D6-8FF8-00022D09712B" },
    66         { "FreeBSD Vinum VM",                           "516E7CB8-6ECF-11D6-8FF8-00022D09712B" },
    67         { "FreeBSD ZFS",                                        "516E7CBA-6ECF-11D6-8FF8-00022D09712B" },
    68         { "Mac OS X HFS+",                                      "48465300-0000-11AA-AA11-00306543ECAC" },
    69         { "Mac OS X UFS",                                       "55465300-0000-11AA-AA11-00306543ECAC" },
    70         { "Mac OS X ZFS",                                       "6A898CC3-1DD2-11B2-99A6-080020736631" },
    71         { "Mac OS X RAID",                                      "52414944-0000-11AA-AA11-00306543ECAC" },
    72         { "Mac OS X RAID, offline",                     "52414944-5F4F-11AA-AA11-00306543ECAC" },
    73         { "Mac OS X Boot",                                      "426F6F74-0000-11AA-AA11-00306543ECAC" },
    74         { "Mac OS X Label",                                     "4C616265-6C00-11AA-AA11-00306543ECAC" },
    75         { "Mac OS X TV Recovery",                       "5265636F-7665-11AA-AA11-00306543ECAC" },
    76         { "Mac OS X Core Storage",                      "53746F72-6167-11AA-AA11-00306543ECAC" },
    77         { "Solaris Boot",                                       "6A82CB45-1DD2-11B2-99A6-080020736631" },
    78         { "Solaris Root",                                       "6A85CF4D-1DD2-11B2-99A6-080020736631" },
    79         { "Solaris Swap",                                       "6A87C46F-1DD2-11B2-99A6-080020736631" },
    80         { "Solaris Backup",                                     "6A8B642B-1DD2-11B2-99A6-080020736631" },
    81         { "Solaris /usr",                                       "6A898CC3-1DD2-11B2-99A6-080020736631" },
    82         { "Solaris /var",                                       "6A8EF2E9-1DD2-11B2-99A6-080020736631" },
    83         { "Solaris /home",                                      "6A90BA39-1DD2-11B2-99A6-080020736631" },
    84         { "Solaris Alternate sector",           "6A9283A5-1DD2-11B2-99A6-080020736631" },
    85         { "Solaris Reserved",                           "6A945A3B-1DD2-11B2-99A6-080020736631" },
    86         { "Solaris Reserved",                           "6A9630D1-1DD2-11B2-99A6-080020736631" },
    87         { "Solaris Reserved",                           "6A980767-1DD2-11B2-99A6-080020736631" },
    88         { "Solaris Reserved",                           "6A96237F-1DD2-11B2-99A6-080020736631" },
    89         { "Solaris Reserved",                           "6A8D2AC7-1DD2-11B2-99A6-080020736631" },
    90         { "NetBSD Swap",                                        "49F48D32-B10E-11DC-B99B-0019D1879648" },
    91         { "NetBSD FFS",                                         "49F48D5A-B10E-11DC-B99B-0019D1879648" },
    92         { "NetBSD LFS",                                         "49F48D82-B10E-11DC-B99B-0019D1879648" },
    93         { "NetBSD RAID",                                        "49F48DAA-B10E-11DC-B99B-0019D1879648" },
    94         { "NetBSD Concatenated",                        "2DB519C4-B10F-11DC-B99B-0019D1879648" },
    95         { "NetBSD Encrypted",                           "2DB519EC-B10F-11DC-B99B-0019D1879648" },
    96         { "ChromeOS ChromeOS kernel",           "FE3A2A5D-4F32-41A7-B725-ACCC3285A309" },
    97         { "ChromeOS rootfs",                            "3CB8E202-3B7E-47DD-8A3C-7FF2A13CFCEC" },
    98         { "ChromeOS future use",                        "2E0A753D-9E48-43B0-8337-B15192CB1B5E" },
    99         { "MidnightBSD Boot",                           "85D5E45E-237C-11E1-B4B3-E89A8F7FC3A7" },
    100         { "MidnightBSD Data",                           "85D5E45A-237C-11E1-B4B3-E89A8F7FC3A7" },
    101         { "MidnightBSD Swap",                           "85D5E45B-237C-11E1-B4B3-E89A8F7FC3A7" },
    102         { "MidnightBSD UFS",                            "0394Ef8B-237E-11E1-B4B3-E89A8F7FC3A7" },
    103         { "MidnightBSD Vinum VM",                       "85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7" },
    104         { "MidnightBSD ZFS",                            "85D5E45D-237C-11E1-B4B3-E89A8F7FC3A7" },
    105         { "Uknown", NULL}       // keep this as the last one! gpt_get_part_type depends on it!
     43        { "Unused entry",                                       "00000000" "0000" "0000" "0000" "000000000000" },
     44        { "MBR partition scheme",                       "024DEE41" "33E7" "11D3" "9D69" "0008C781F39F" },
     45        { "EFI System",                                         "C12A7328" "F81F" "11D2" "BA4B" "00A0C93EC93B" },
     46        { "BIOS Boot",                                          "21686148" "6449" "6E6F" "744E" "656564454649" },
     47        { "Windows Reserved",                           "E3C9E316" "0B5C" "4DB8" "817D" "F92DF00215AE" },
     48        { "Windows Basic data",                         "EBD0A0A2" "B9E5" "4433" "87C0" "68B6B72699C7" },
     49        { "Windows LDM metadata",                       "5808C8AA" "7E8F" "42E0" "85D2" "E1E90434CFB3" },
     50        { "Windows LDM data",                           "AF9B60A0" "1431" "4F62" "BC68" "3311714A69AD" },
     51        { "Windows Recovery Environment",       "DE94BBA4" "06D1" "4D40" "A16A" "BFD50179D6AC" },
     52        { "Windows IBM GPFS",                           "37AFFC90" "EF7D" "4E96" "91C3" "2D7AE055B174" },
     53        { "Windows Cluster metadata",           "DB97DBA9" "0840" "4BAE" "97F0" "FFB9A327C7E1" },
     54        { "HP-UX Data",                                         "75894C1E" "3AEB" "11D3" "B7C1" "7B03A0000000" },
     55        { "HP-UX Service",                                      "E2A1E728" "32E3" "11D6" "A682" "7B03A0000000" },
     56        { "Linux filesystem data",                      "EBD0A0A2" "B9E5" "4433" "87C0" "68B6B72699C7" },
     57        { "Linux filesystem data",                      "0FC63DAF" "8483" "4772" "8E79" "3D69D8477DE4" },
     58        { "Linux RAID",                                         "A19D880F" "05FC" "4D3B" "A006" "743F0F84911E" },
     59        { "Linux Swap",                                         "0657FD6D" "A4AB" "43C4" "84E5" "0933C84B4F4F" },
     60        { "Linux LVM",                                          "E6D6D379" "F507" "44C2" "A23C" "238F2A3DF928" },
     61        { "Linux Reserved",                                     "8DA63339" "0007" "60C0" "C436" "083AC8230908" },
     62        { "FreeBSD Boot",                                       "83BD6B9D" "7F41" "11DC" "BE0B" "001560B84F0F" },
     63        { "FreeBSD Data",                                       "516E7CB4" "6ECF" "11D6" "8FF8" "00022D09712B" },
     64        { "FreeBSD Swap",                                       "516E7CB5" "6ECF" "11D6" "8FF8" "00022D09712B" },
     65        { "FreeBSD UFS",                                        "516E7CB6" "6ECF" "11D6" "8FF8" "00022D09712B" },
     66        { "FreeBSD Vinum VM",                           "516E7CB8" "6ECF" "11D6" "8FF8" "00022D09712B" },
     67        { "FreeBSD ZFS",                                        "516E7CBA" "6ECF" "11D6" "8FF8" "00022D09712B" },
     68        { "Mac OS X HFS+",                                      "48465300" "0000" "11AA" "AA11" "00306543ECAC" },
     69        { "Mac OS X UFS",                                       "55465300" "0000" "11AA" "AA11" "00306543ECAC" },
     70        { "Mac OS X ZFS",                                       "6A898CC3" "1DD2" "11B2" "99A6" "080020736631" },
     71        { "Mac OS X RAID",                                      "52414944" "0000" "11AA" "AA11" "00306543ECAC" },
     72        { "Mac OS X RAID, offline",                     "52414944" "5F4F" "11AA" "AA11" "00306543ECAC" },
     73        { "Mac OS X Boot",                                      "426F6F74" "0000" "11AA" "AA11" "00306543ECAC" },
     74        { "Mac OS X Label",                                     "4C616265" "6C00" "11AA" "AA11" "00306543ECAC" },
     75        { "Mac OS X TV Recovery",                       "5265636F" "7665" "11AA" "AA11" "00306543ECAC" },
     76        { "Mac OS X Core Storage",                      "53746F72" "6167" "11AA" "AA11" "00306543ECAC" },
     77        { "Solaris Boot",                                       "6A82CB45" "1DD2" "11B2" "99A6" "080020736631" },
     78        { "Solaris Root",                                       "6A85CF4D" "1DD2" "11B2" "99A6" "080020736631" },
     79        { "Solaris Swap",                                       "6A87C46F" "1DD2" "11B2" "99A6" "080020736631" },
     80        { "Solaris Backup",                                     "6A8B642B" "1DD2" "11B2" "99A6" "080020736631" },
     81        { "Solaris /usr",                                       "6A898CC3" "1DD2" "11B2" "99A6" "080020736631" },
     82        { "Solaris /var",                                       "6A8EF2E9" "1DD2" "11B2" "99A6" "080020736631" },
     83        { "Solaris /home",                                      "6A90BA39" "1DD2" "11B2" "99A6" "080020736631" },
     84        { "Solaris Alternate sector",           "6A9283A5" "1DD2" "11B2" "99A6" "080020736631" },
     85        { "Solaris Reserved",                           "6A945A3B" "1DD2" "11B2" "99A6" "080020736631" },
     86        { "Solaris Reserved",                           "6A9630D1" "1DD2" "11B2" "99A6" "080020736631" },
     87        { "Solaris Reserved",                           "6A980767" "1DD2" "11B2" "99A6" "080020736631" },
     88        { "Solaris Reserved",                           "6A96237F" "1DD2" "11B2" "99A6" "080020736631" },
     89        { "Solaris Reserved",                           "6A8D2AC7" "1DD2" "11B2" "99A6" "080020736631" },
     90        { "NetBSD Swap",                                        "49F48D32" "B10E" "11DC" "B99B" "0019D1879648" },
     91        { "NetBSD FFS",                                         "49F48D5A" "B10E" "11DC" "B99B" "0019D1879648" },
     92        { "NetBSD LFS",                                         "49F48D82" "B10E" "11DC" "B99B" "0019D1879648" },
     93        { "NetBSD RAID",                                        "49F48DAA" "B10E" "11DC" "B99B" "0019D1879648" },
     94        { "NetBSD Concatenated",                        "2DB519C4" "B10F" "11DC" "B99B" "0019D1879648" },
     95        { "NetBSD Encrypted",                           "2DB519EC" "B10F" "11DC" "B99B" "0019D1879648" },
     96        { "ChromeOS ChromeOS kernel",           "FE3A2A5D" "4F32" "41A7" "B725" "ACCC3285A309" },
     97        { "ChromeOS rootfs",                            "3CB8E202" "3B7E" "47DD" "8A3C" "7FF2A13CFCEC" },
     98        { "ChromeOS future use",                        "2E0A753D" "9E48" "43B0" "8337" "B15192CB1B5E" },
     99        { "MidnightBSD Boot",                           "85D5E45E" "237C" "11E1" "B4B3" "E89A8F7FC3A7" },
     100        { "MidnightBSD Data",                           "85D5E45A" "237C" "11E1" "B4B3" "E89A8F7FC3A7" },
     101        { "MidnightBSD Swap",                           "85D5E45B" "237C" "11E1" "B4B3" "E89A8F7FC3A7" },
     102        { "MidnightBSD UFS",                            "0394Ef8B" "237E" "11E1" "B4B3" "E89A8F7FC3A7" },
     103        { "MidnightBSD Vinum VM",                       "85D5E45C" "237C" "11E1" "B4B3" "E89A8F7FC3A7" },
     104        { "MidnightBSD ZFS",                            "85D5E45D" "237C" "11E1" "B4B3" "E89A8F7FC3A7" },
     105        { "Uknown", NULL} /* keep this as the last one! gpt_get_part_type depends on it! */
    106106};
     107
     108
     109
  • uspace/lib/gpt/libgpt.c

    r6e8e4e19 r1c8bfe8  
    5151#include "libgpt.h"
    5252
    53 static int load_and_check_header(service_id_t handle, aoff64_t addr, size_t b_size, gpt_header_t * header);
     53static int load_and_check_header(service_id_t handle, aoff64_t addr, size_t b_size, gpt_header_t *header);
    5454static gpt_partitions_t * alloc_part_array(uint32_t num);
    55 static int extend_part_array(gpt_partitions_t * p);
    56 static int reduce_part_array(gpt_partitions_t * p);
     55static int extend_part_array(gpt_partitions_t *);
     56static int reduce_part_array(gpt_partitions_t *);
    5757static long long nearest_larger_int(double a);
    58 static int gpt_memcmp(const void * a, const void * b, size_t len);
     58static uint8_t get_byte(const char *);
     59
     60/** Allocate memory for gpt label */
     61gpt_label_t * gpt_alloc_label(void)
     62{
     63        gpt_label_t *label = malloc(sizeof(gpt_label_t));
     64        if (label == NULL)
     65                return NULL;
     66       
     67        label->gpt = NULL;
     68        label->parts = NULL;
     69        label->device = 0;
     70       
     71        return label;
     72}
     73
     74/** Free gpt_label_t structure */
     75void gpt_free_label(gpt_label_t *label)
     76{
     77        if (label->gpt != NULL)
     78                gpt_free_gpt(label->gpt);
     79       
     80        if (label->parts != NULL)
     81                gpt_free_partitions(label->parts);
     82       
     83        free(label);
     84}
    5985
    6086/** Allocate memory for gpt header */
    61 gpt_t * gpt_alloc_gpt_header(void)
    62 {
    63         return malloc(sizeof(gpt_t));
     87gpt_t * gpt_alloc_header(size_t size)
     88{
     89        gpt_t *gpt = malloc(sizeof(gpt_t));
     90        if (gpt == NULL)
     91                return NULL;
     92       
     93        // We might need only sizeof(gpt_header_t),
     94        // but we should follow specs and have
     95        // zeroes through all the rest of the block
     96        size_t final_size = size > sizeof(gpt_header_t) ? size : sizeof(gpt_header_t);
     97        gpt->header = malloc(final_size);
     98        if (gpt->header == NULL) {
     99                free(gpt);
     100                return NULL;
     101        }
     102       
     103        memset(gpt->header, 0, final_size);
     104       
     105        return gpt;
     106}
     107
     108/** free() GPT header including gpt->header_lba */
     109void gpt_free_gpt(gpt_t *gpt)
     110{
     111        free(gpt->header);
     112        free(gpt);
    64113}
    65114
    66115/** Read GPT from specific device
    67  * @param       dev_handle      device to read GPT from
    68  *
    69  * @return                              GPT record on success, NULL on error
    70  */
    71 gpt_t * gpt_read_gpt_header(service_id_t dev_handle)
     116 * @param label        label structure to fill
     117 * @param dev_handle   device to read GPT from
     118 *
     119 * @return             EOK on success, errorcode on error
     120 */
     121int gpt_read_header(gpt_label_t *label, service_id_t dev_handle)
    72122{
    73123        int rc;
     
    76126        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
    77127        if (rc != EOK)
    78                 return NULL;
     128                return rc;
    79129       
    80130        rc = block_get_bsize(dev_handle, &b_size);
    81         if (rc != EOK) {
    82                 errno = rc;
    83                 return NULL;
    84         }
    85        
    86         gpt_t * gpt = malloc(sizeof(gpt_t));
    87         if (gpt == NULL) {
    88                 errno = ENOMEM;
    89                 return NULL;
    90         }
    91 
    92         gpt->raw_data = malloc(b_size); // We might need only sizeof(gpt_header_t),
    93         if (gpt == NULL) {                              // but we should follow specs and have
    94                 free(gpt);                                      // zeroes through all the rest of the block
    95                 errno = ENOMEM;
    96                 return NULL;
    97         }
    98        
    99        
    100         rc = load_and_check_header(dev_handle, GPT_HDR_BA, b_size, gpt->raw_data);
     131        if (rc != EOK)
     132                return rc;
     133       
     134        if (label->gpt == NULL) {
     135                label->gpt = gpt_alloc_header(b_size);
     136                if (label->gpt == NULL)
     137                        return ENOMEM;
     138        }
     139       
     140        rc = load_and_check_header(dev_handle, GPT_HDR_BA, b_size, label->gpt->header);
    101141        if (rc == EBADCHECKSUM || rc == EINVAL) {
    102142                aoff64_t n_blocks;
    103143                rc = block_get_nblocks(dev_handle, &n_blocks);
    104                 if (rc != EOK) {
    105                         errno = rc;
     144                if (rc != EOK)
    106145                        goto fail;
    107                 }
    108 
    109                 rc = load_and_check_header(dev_handle, n_blocks - 1, b_size, gpt->raw_data);
    110                 if (rc == EBADCHECKSUM || rc == EINVAL) {
    111                         errno = rc;
     146
     147                rc = load_and_check_header(dev_handle, n_blocks - 1, b_size, label->gpt->header);
     148                if (rc == EBADCHECKSUM || rc == EINVAL)
    112149                        goto fail;
    113                 }
    114         }
    115        
    116         gpt->device = dev_handle;
     150        }
     151       
     152        label->device = dev_handle;
    117153        block_fini(dev_handle);
    118         return gpt;
     154        return EOK;
    119155       
    120156fail:
    121157        block_fini(dev_handle);
    122         gpt_free_gpt(gpt);
    123         return NULL;
     158        gpt_free_gpt(label->gpt);
     159        label->gpt = NULL;
     160        return rc;
    124161}
    125162
    126163/** Write GPT header to device
    127  * @param header                GPT header to be written
    128  * @param dev_handle    device handle to write the data to
    129  *
    130  * @return                              0 on success, libblock error code otherwise
    131  *
    132  * Note: Firstly write partitions (if changed), then gpt header.
    133  */
    134 int gpt_write_gpt_header(gpt_t * gpt, service_id_t dev_handle)
     164 * @param label        GPT label header to be written
     165 * @param dev_handle   device handle to write the data to
     166 *
     167 * @return             EOK on success, libblock error code otherwise
     168 *
     169 * Note: Firstly write partitions (if modified), then gpt header.
     170 */
     171int gpt_write_header(gpt_label_t *label, service_id_t dev_handle)
    135172{
    136173        int rc;
    137174        size_t b_size;
    138175
    139         gpt->raw_data->header_crc32 = 0;
    140         gpt->raw_data->header_crc32 = compute_crc32((uint8_t *) gpt->raw_data,
    141                                         uint32_t_le2host(gpt->raw_data->header_size));
     176        label->gpt->header->header_crc32 = 0;
     177        label->gpt->header->header_crc32 = compute_crc32((uint8_t *) label->gpt->header,
     178                                        uint32_t_le2host(label->gpt->header->header_size));
    142179
    143180        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
    144         if (rc != EOK)
     181        if (rc != EOK && rc != EEXIST)
    145182                return rc;
    146183
     
    150187
    151188        /* Write to main GPT header location */
    152         rc = block_write_direct(dev_handle, GPT_HDR_BA, GPT_HDR_BS, gpt->raw_data);
    153         if (rc != EOK)
     189        rc = block_write_direct(dev_handle, GPT_HDR_BA, GPT_HDR_BS, label->gpt->header);
     190        if (rc != EOK) {
    154191                block_fini(dev_handle);
    155192                return rc;
     193        }
    156194
    157195        aoff64_t n_blocks;
    158196        rc = block_get_nblocks(dev_handle, &n_blocks);
    159         if (rc != EOK)
    160                 return rc;
     197        if (rc != EOK) {
     198                block_fini(dev_handle);
     199                return rc;
     200        }
    161201
    162202        /* Write to backup GPT header location */
    163203        //FIXME: those idiots thought it would be cool to have these fields in reverse order...
    164         rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, gpt->raw_data);
     204        rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, label->gpt->header);
    165205        block_fini(dev_handle);
    166206        if (rc != EOK)
     
    171211
    172212/** Alloc partition array */
    173 gpt_partitions_t *      gpt_alloc_partitions()
     213gpt_partitions_t * gpt_alloc_partitions()
    174214{
    175215        return alloc_part_array(128);
     
    177217
    178218/** Parse partitions from GPT
    179  * @param gpt   GPT to be parsed
    180  *
    181  * @return              partition linked list pointer or NULL on error
    182  *                              error code is stored in errno
    183  */
    184 gpt_partitions_t * gpt_read_partitions(gpt_t * gpt)
     219 * @param label   GPT label to be parsed
     220 *
     221 * @return        EOK on success, errorcode otherwise
     222 */
     223int gpt_read_partitions(gpt_label_t *label)
    185224{
    186225        int rc;
    187226        unsigned int i;
    188         gpt_partitions_t * res;
    189         uint32_t fill = uint32_t_le2host(gpt->raw_data->fillries);
    190         uint32_t ent_size = uint32_t_le2host(gpt->raw_data->entry_size);
    191         uint64_t ent_lba = uint64_t_le2host(gpt->raw_data->entry_lba);
    192 
    193         res = alloc_part_array(fill);
    194         if (res == NULL) {
    195                 //errno = ENOMEM; // already set in alloc_part_array()
    196                 return NULL;
     227        uint32_t fill = uint32_t_le2host(label->gpt->header->fillries);
     228        uint32_t ent_size = uint32_t_le2host(label->gpt->header->entry_size);
     229        uint64_t ent_lba = uint64_t_le2host(label->gpt->header->entry_lba);
     230       
     231        if (label->parts == NULL) {
     232                label->parts = alloc_part_array(fill);
     233                if (label->parts == NULL) {
     234                        return ENOMEM;
     235                }
    197236        }
    198237
     
    200239         *  - we don't need more bytes
    201240         *  - the size of GPT partition entry can be different to 128 bytes */
    202         rc = block_init(EXCHANGE_SERIALIZE, gpt->device, sizeof(gpt_entry_t));
    203         if (rc != EOK) {
    204                 gpt_free_partitions(res);
    205                 errno = rc;
    206                 return NULL;
    207         }
     241        rc = block_init(EXCHANGE_SERIALIZE, label->device, sizeof(gpt_entry_t));
     242        if (rc != EOK)
     243                goto fail;
    208244
    209245        size_t block_size;
    210         rc = block_get_bsize(gpt->device, &block_size);
    211         if (rc != EOK) {
    212                 gpt_free_partitions(res);
    213                 errno = rc;
    214                 return NULL;
    215         }
     246        rc = block_get_bsize(label->device, &block_size);
     247        if (rc != EOK)
     248                goto fail;
    216249
    217250        //size_t bufpos = 0;
     
    226259        for (i = 0; i < fill; ++i) {
    227260                //FIXME: this does bypass cache...
    228                 rc = block_read_bytes_direct(gpt->device, pos, sizeof(gpt_entry_t), res->part_array + i);
     261                rc = block_read_bytes_direct(label->device, pos, sizeof(gpt_entry_t), label->parts->part_array + i);
    229262                //FIXME: but seqread() is just too complex...
    230263                //rc = block_seqread(gpt->device, &bufpos, &buflen, &pos, res->part_array[i], sizeof(gpt_entry_t));
    231264                pos += ent_size;
    232265
    233                 if (rc != EOK) {
    234                         gpt_free_partitions(res);
    235                         errno = rc;
    236                         return NULL;
    237                 }
     266                if (rc != EOK)
     267                        goto fail;
    238268        }
    239269
     
    243273         * on all of the partition entry array.
    244274         */
    245         uint32_t crc = compute_crc32((uint8_t *) res->part_array, res->fill * sizeof(gpt_entry_t));
    246 
    247         if(uint32_t_le2host(gpt->raw_data->pe_array_crc32) != crc)
     275        uint32_t crc = compute_crc32((uint8_t *) label->parts->part_array, label->parts->fill * sizeof(gpt_entry_t));
     276
     277        if(uint32_t_le2host(label->gpt->header->pe_array_crc32) != crc)
    248278        {
    249                 gpt_free_partitions(res);
    250                 errno = EBADCHECKSUM;
    251                 return NULL;
    252         }
    253 
    254         return res;
     279                rc = EBADCHECKSUM;
     280                goto fail;
     281        }
     282
     283        return EOK;
     284       
     285fail:
     286        gpt_free_partitions(label->parts);
     287        label->parts = NULL;
     288        return rc;
    255289}
    256290
    257291/** Write GPT and partitions to device
    258  * @param parts                 partition list to be written
    259  * @param header                GPT header belonging to the 'parts' partitions
    260  * @param dev_handle    device to write the data to
    261  *
    262  * @return                              returns EOK on succes, specific error code otherwise
    263  */
    264 int gpt_write_partitions(gpt_partitions_t * parts, gpt_t * gpt, service_id_t dev_handle)
     292 * @param label        label to write
     293 * @param dev_handle   device to write the data to
     294 *
     295 * @return             returns EOK on succes, errorcode otherwise
     296 */
     297int gpt_write_partitions(gpt_label_t *label, service_id_t dev_handle)
    265298{
    266299        int rc;
    267300        size_t b_size;
    268 
    269         gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->fill * gpt->raw_data->entry_size);
    270 
    271         rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
    272         if (rc != EOK)
    273                 return rc;
    274 
     301        uint32_t e_size = uint32_t_le2host(label->gpt->header->entry_size);
     302        size_t fill = label->parts->fill > GPT_MIN_PART_NUM ? label->parts->fill : GPT_MIN_PART_NUM;
     303       
     304        label->gpt->header->pe_array_crc32 = compute_crc32(
     305                                       (uint8_t *) label->parts->part_array,
     306                                       fill * e_size);
     307       
     308        /* comm_size of 4096 is ignored */
     309        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 4096);
     310        if (rc != EOK && rc != EEXIST)
     311                return rc;
     312       
    275313        rc = block_get_bsize(dev_handle, &b_size);
    276314        if (rc != EOK)
    277                 return rc;
    278 
    279         /* Write to main GPT partition array location */
    280         rc = block_write_direct(dev_handle, uint64_t_le2host(gpt->raw_data->entry_lba),
    281                         nearest_larger_int((uint64_t_le2host(gpt->raw_data->entry_size) * parts->fill) / b_size),
    282                         parts->part_array);
    283         if (rc != EOK)
    284                 block_fini(dev_handle);
    285                 return rc;
    286 
     315                goto fail;
     316       
    287317        aoff64_t n_blocks;
    288318        rc = block_get_nblocks(dev_handle, &n_blocks);
    289319        if (rc != EOK)
    290                 return rc;
    291 
     320                goto fail;
     321       
    292322        /* Write to backup GPT partition array location */
    293323        //rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, header->raw_data);
     324        if (rc != EOK)
     325                goto fail;
     326       
     327        /* Write to main GPT partition array location */
     328        rc = block_write_direct(dev_handle, uint64_t_le2host(label->gpt->header->entry_lba),
     329                        nearest_larger_int((uint64_t_le2host(label->gpt->header->entry_size) * label->parts->fill) / b_size),
     330                        label->parts->part_array);
     331        if (rc != EOK)
     332                goto fail;
     333       
     334        return gpt_write_header(label, dev_handle);
     335       
     336fail:
    294337        block_fini(dev_handle);
    295         if (rc != EOK)
    296                 return rc;
    297 
    298 
    299         return gpt_write_gpt_header(gpt, dev_handle);
     338        return rc;
    300339}
    301340
    302341/** Alloc new partition
    303342 *
    304  * @param parts         partition table to carry new partition
    305  *
    306  * @return                      returns pointer to the new partition or NULL on ENOMEM
    307  *
    308  * Note: use either gpt_alloc_partition or gpt_add_partition. The first
    309  * returns a pointer to write your data to, the second copies the data
    310  * (and does not free the memory).
    311  */
    312 gpt_part_t * gpt_alloc_partition(gpt_partitions_t * parts)
    313 {
    314         if (parts->fill == parts->arr_size) {
    315                 if (extend_part_array(parts) == -1)
    316                         return NULL;
    317         }
    318 
    319         return parts->part_array + parts->fill++;
     343 * @return        returns pointer to the new partition or NULL
     344 *
     345 * Note: use either gpt_alloc_partition or gpt_get_partition.
     346 * This returns a memory block (zero-filled) and needs gpt_add_partition()
     347 * to be called to insert it into a partition array.
     348 * Requires you to call gpt_free_partition afterwards.
     349 */
     350gpt_part_t * gpt_alloc_partition(void)
     351{
     352        gpt_part_t *p = malloc(sizeof(gpt_part_t));
     353        if (p == NULL)
     354                return NULL;
     355       
     356        memset(p, 0, sizeof(gpt_part_t));
     357       
     358        return p;
     359}
     360
     361/** Alloc new partition already inside the label
     362 *
     363 * @param label   label to carry new partition
     364 *
     365 * @return        returns pointer to the new partition or NULL on ENOMEM
     366 *
     367 * Note: use either gpt_alloc_partition or gpt_get_partition.
     368 * This one returns a pointer to the first empty structure already
     369 * inside the array, so don't call gpt_add_partition() afterwards.
     370 * This is the one you will usually want.
     371 */
     372gpt_part_t * gpt_get_partition(gpt_label_t *label)
     373{
     374        gpt_part_t *p;
     375       
     376        /* Find the first empty entry */
     377        do {
     378                if (label->parts->fill == label->parts->arr_size) {
     379                        if (extend_part_array(label->parts) == -1)
     380                                return NULL;
     381                }
     382               
     383                p = label->parts->part_array + label->parts->fill++;
     384               
     385        } while (gpt_get_part_type(p) != GPT_PTE_UNUSED);
     386       
     387        return p;
     388}
     389
     390/** Get partition already inside the label
     391 *
     392 * @param label   label to carrying the partition
     393 * @param idx     index of the partition
     394 *
     395 * @return        returns pointer to the partition
     396 *                or NULL when out of range
     397 *
     398 * Note: For new partitions use either gpt_alloc_partition or
     399 * gpt_get_partition unless you want a partition at a specific place.
     400 * This returns a pointer to a structure already inside the array,
     401 * so don't call gpt_add_partition() afterwards.
     402 * This function is handy when you want to change already existing
     403 * partition or to simply write somewhere in the middle. This works only
     404 * for indexes smaller than either 128 or the actual number of filled
     405 * entries.
     406 */
     407gpt_part_t * gpt_get_partition_at(gpt_label_t *label, size_t idx)
     408{
     409        return NULL;
     410       
     411        if (idx >= GPT_MIN_PART_NUM && idx >= label->parts->fill)
     412                return NULL;
     413       
     414        return label->parts->part_array + idx;
    320415}
    321416
    322417/** Copy partition into partition array
    323418 *
    324  * @param parts                 target partition array
     419 * @param parts                 target label
    325420 * @param partition             source partition to copy
    326421 *
    327422 * @return                              -1 on error, 0 otherwise
    328423 *
    329  * Note: use either gpt_alloc_partition or gpt_add_partition. The first
    330  * returns a pointer to write your data to, the second copies the data
    331  * (and does not free the memory).
    332  */
    333 int gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition)
    334 {
    335         if (parts->fill == parts->arr_size) {
    336                 if (extend_part_array(parts) == -1)
     424 * Note: for use with gpt_alloc_partition() only. You will get
     425 * duplicates with gpt_get_partition().
     426 */
     427int gpt_add_partition(gpt_label_t *label, gpt_part_t *partition)
     428{
     429        if (label->parts->fill == label->parts->arr_size) {
     430                if (extend_part_array(label->parts) == -1)
    337431                        return ENOMEM;
    338432        }
    339         extend_part_array(parts);
    340         return EOK;;
     433       
     434        memcpy(label->parts->part_array + label->parts->fill++,
     435               partition, sizeof(gpt_part_t));
     436       
     437        return EOK;
    341438}
    342439
    343440/** Remove partition from array
    344  *
    345  * @param idx           index of the partition to remove
    346  *
    347  * @return                      -1 on error, 0 otherwise
     441 * @param label   label to remove from
     442 * @param idx     index of the partition to remove
     443 *
     444 * @return        EOK on success, ENOMEM on array reduction failure
    348445 *
    349446 * Note: even if it fails, the partition still gets removed. Only
    350447 * reducing the array failed.
    351448 */
    352 int gpt_remove_partition(gpt_partitions_t * parts, size_t idx)
    353 {
    354         if (idx != parts->fill - 1) {
    355                 memcpy(parts->part_array + idx, parts->part_array + parts->fill - 1, sizeof(gpt_entry_t));
    356                 parts->fill -= 1;
    357         }
    358 
    359         if (parts->fill < (parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
    360                 if (reduce_part_array(parts) == -1)
    361                         return -1;
    362         }
    363 
    364         return 0;
    365 }
    366 
    367 /** free() GPT header including gpt->header_lba */
    368 void gpt_free_gpt(gpt_t * gpt)
    369 {
    370         free(gpt->raw_data);
    371         free(gpt);
     449int gpt_remove_partition(gpt_label_t *label, size_t idx)
     450{
     451        if (idx >= label->parts->fill)
     452                return EINVAL;
     453       
     454        /* FIXME!
     455         * If we allow blank spots, we break the array. If we have more than
     456         * 128 partitions in the array and then remove something from
     457         * the first 128 partitions, we would forget to write the last one.*/
     458        memset(label->parts->part_array + idx, 0, sizeof(gpt_entry_t));
     459       
     460        label->parts->fill -= 1;
     461       
     462        /* FIXME!
     463         * We cannot reduce the array so simply. We may have some partitions
     464         * there since we allow blank spots.*/
     465        if (label->parts->fill < (label->parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
     466                if (reduce_part_array(label->parts) == ENOMEM)
     467                        return ENOMEM;
     468        }
     469
     470        return EOK;
    372471}
    373472
     
    388487{
    389488        size_t i;
     489       
    390490        for (i = 0; gpt_ptypes[i].guid != NULL; i++) {
    391                 if (gpt_memcmp(p->part_type, gpt_ptypes[i].guid, 16) == 0) {
    392                         break;
    393                 }
    394         }
     491                if (p->part_type[3] == get_byte(gpt_ptypes[i].guid +0) &&
     492                        p->part_type[2] == get_byte(gpt_ptypes[i].guid +2) &&
     493                        p->part_type[1] == get_byte(gpt_ptypes[i].guid +4) &&
     494                        p->part_type[0] == get_byte(gpt_ptypes[i].guid +6) &&
     495                       
     496                        p->part_type[5] == get_byte(gpt_ptypes[i].guid +8) &&
     497                        p->part_type[4] == get_byte(gpt_ptypes[i].guid +10) &&
     498                       
     499                        p->part_type[7] == get_byte(gpt_ptypes[i].guid +12) &&
     500                        p->part_type[6] == get_byte(gpt_ptypes[i].guid +14) &&
     501                       
     502                        p->part_type[8] == get_byte(gpt_ptypes[i].guid +16) &&
     503                        p->part_type[9] == get_byte(gpt_ptypes[i].guid +18) &&
     504                        p->part_type[10] == get_byte(gpt_ptypes[i].guid +20) &&
     505                        p->part_type[11] == get_byte(gpt_ptypes[i].guid +22) &&
     506                        p->part_type[12] == get_byte(gpt_ptypes[i].guid +24) &&
     507                        p->part_type[13] == get_byte(gpt_ptypes[i].guid +26) &&
     508                        p->part_type[14] == get_byte(gpt_ptypes[i].guid +28) &&
     509                        p->part_type[15] == get_byte(gpt_ptypes[i].guid +30))
     510                                break;
     511        }
     512       
    395513        return i;
    396514}
     
    449567}
    450568
    451 
     569/** Get partition name */
    452570unsigned char * gpt_get_part_name(gpt_part_t * p)
    453571{
     
    456574
    457575/** Copy partition name */
    458 void gpt_set_part_name(gpt_part_t * p, char * name[], size_t length)
     576void gpt_set_part_name(gpt_part_t *p, char *name, size_t length)
    459577{
    460578        if (length >= 72)
     
    561679        if(p->arr_size > GPT_MIN_PART_NUM) {
    562680                unsigned int nsize = p->arr_size / 2;
     681                nsize = nsize > GPT_MIN_PART_NUM ? nsize : GPT_MIN_PART_NUM;
    563682                gpt_entry_t * tmp = malloc(nsize * sizeof(gpt_entry_t));
    564                 if(tmp == NULL) {
    565                         errno = ENOMEM;
    566                         return -1;
    567                 }
     683                if(tmp == NULL)
     684                        return ENOMEM;
    568685
    569686                memcpy(tmp, p->part_array, p->fill < nsize ? p->fill  : nsize);
     
    586703}
    587704
    588 static int gpt_memcmp(const void * a, const void * b, size_t len)
    589 {
    590         size_t i;
    591         int diff;
    592         const unsigned char * x = a;
    593         const unsigned char * y = b;
    594 
    595         for (i = 0; i < len; i++) {
    596                 diff = (int)*(x++) - (int)*(y++);
    597                 if (diff != 0) {
    598                         return diff;
    599                 }
    600         }
    601         return 0;
    602 }
    603 
    604 
    605 
    606 
     705static uint8_t get_byte(const char * c)
     706{
     707        uint8_t val = 0;
     708        char hex[3] = {*c, *(c+1), 0};
     709       
     710        errno = str_uint8_t(hex, NULL, 16, false, &val);
     711        return val;
     712}
     713
     714
     715
     716
  • uspace/lib/gpt/libgpt.h

    r6e8e4e19 r1c8bfe8  
    5353#define GPT_IGNORE_FILL_NUM 10
    5454
     55/** Unused partition entry */
     56#define GPT_PTE_UNUSED 0
     57
    5558/** GPT header signature ("EFI PART" in ASCII) */
    5659extern const uint8_t efi_signature[8];
     
    8689typedef struct {
    8790        /** Raw header. Has more bytes alloced than sizeof(gpt_header_t)!
    88          * See gpt_read_gpt_header() to know why. */
    89         gpt_header_t * raw_data;
    90         /** Device where the data are from */
    91         service_id_t device;
    92         /** Linked list of partitions (initially NULL) */
     91         * See gpt_alloc_header() to know why. */
     92        gpt_header_t *header;
    9393} gpt_t;
    9494
     
    123123        size_t arr_size;
    124124        /** Resizable partition array */
    125         gpt_entry_t * part_array;
     125        gpt_entry_t *part_array;
    126126} gpt_partitions_t;
    127127
    128128
    129129typedef struct gpt_table {
    130         gpt_t * gpt;
    131         gpt_partitions_t * parts;
     130        gpt_t *gpt;
     131        gpt_partitions_t *parts;
     132        service_id_t device;
    132133} gpt_label_t;
    133134
    134135struct partition_type {
    135         const char * desc;
    136         const char * guid;
     136        const char *desc;
     137        const char *guid;
    137138};
    138139
    139140extern const struct partition_type gpt_ptypes[];
    140141
     142extern gpt_label_t * gpt_alloc_label(void);
     143extern void gpt_free_label(gpt_label_t *);
    141144
    142 extern gpt_t * gpt_alloc_gpt_header(void);
    143 extern gpt_t * gpt_read_gpt_header(service_id_t dev_handle);
    144 extern int     gpt_write_gpt_header(gpt_t * header, service_id_t dev_handle);
     145extern gpt_t * gpt_alloc_header(size_t);
     146extern int     gpt_read_header(gpt_label_t *, service_id_t);
     147extern int     gpt_write_header(gpt_label_t *, service_id_t);
    145148
    146149extern gpt_partitions_t * gpt_alloc_partitions(void);
    147 extern gpt_partitions_t * gpt_read_partitions(gpt_t * gpt);
    148 extern int             gpt_write_partitions(gpt_partitions_t * parts, gpt_t * header, service_id_t dev_handle);
    149 extern gpt_part_t *    gpt_alloc_partition (gpt_partitions_t * parts);
    150 extern int             gpt_add_partition   (gpt_partitions_t * parts, gpt_part_t * partition);
    151 extern int             gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
     150extern int             gpt_read_partitions (gpt_label_t *);
     151extern int             gpt_write_partitions(gpt_label_t *, service_id_t);
     152extern gpt_part_t *    gpt_alloc_partition (void);
     153extern gpt_part_t *    gpt_get_partition   (gpt_label_t *);
     154extern gpt_part_t *    gpt_get_partition_at(gpt_label_t *, size_t);
     155extern int             gpt_add_partition   (gpt_label_t *, gpt_part_t *);
     156extern int             gpt_remove_partition(gpt_label_t *, size_t);
    152157
    153 extern size_t          gpt_get_part_type(gpt_part_t * p);
    154 extern void            gpt_set_part_type(gpt_part_t * p, size_t type);
    155 extern void            gpt_set_start_lba(gpt_part_t * p, uint64_t start);
    156 extern uint64_t        gpt_get_start_lba(gpt_part_t * p);
    157 extern void            gpt_set_end_lba  (gpt_part_t * p, uint64_t end);
    158 extern uint64_t        gpt_get_end_lba  (gpt_part_t * p);
    159 extern unsigned char * gpt_get_part_name(gpt_part_t * p);
    160 extern void            gpt_set_part_name(gpt_part_t * p, char * name[], size_t length);
    161 extern bool            gpt_get_flag     (gpt_part_t * p, GPT_ATTR flag);
    162 extern void            gpt_set_flag     (gpt_part_t * p, GPT_ATTR flag, bool value);
     158extern size_t          gpt_get_part_type(gpt_part_t *);
     159extern void            gpt_set_part_type(gpt_part_t *, size_t);
     160extern void            gpt_set_start_lba(gpt_part_t *, uint64_t);
     161extern uint64_t        gpt_get_start_lba(gpt_part_t *);
     162extern void            gpt_set_end_lba  (gpt_part_t *, uint64_t);
     163extern uint64_t        gpt_get_end_lba  (gpt_part_t *);
     164extern unsigned char * gpt_get_part_name(gpt_part_t *);
     165extern void            gpt_set_part_name(gpt_part_t *, char *, size_t);
     166extern bool            gpt_get_flag     (gpt_part_t *, GPT_ATTR);
     167extern void            gpt_set_flag     (gpt_part_t *, GPT_ATTR, bool);
    163168
    164169
    165170
    166 #define gpt_part_foreach(parts, iterator) \
    167                 for(gpt_part_t * iterator = (parts)->part_array; \
    168                     iterator < (parts)->part_array + (parts)->fill; ++iterator)
     171#define gpt_part_foreach(label, iterator) \
     172                for(gpt_part_t * iterator = (label)->parts->part_array; \
     173                    iterator < (label)->parts->part_array + (label)->parts->fill; ++iterator)
    169174
    170 extern void gpt_free_gpt(gpt_t * gpt);
    171 extern void gpt_free_partitions(gpt_partitions_t * parts);
     175extern void gpt_free_gpt(gpt_t *);
     176extern void gpt_free_partitions(gpt_partitions_t *);
    172177
    173178#endif
  • uspace/lib/mbr/libmbr.c

    r6e8e4e19 r1c8bfe8  
    9494 */
    9595int mbr_read_mbr(mbr_label_t *label, service_id_t dev_handle)
    96 {
    97         if (label == NULL)
    98                 return EINVAL;
    99        
     96{       
    10097        int rc;
    10198       
     
    195192               
    196193                rc_ext = decode_part(&(label->mbr->raw_data.pte[i]), p, 0);
    197                 printf("p: %d %u %u\n", rc_ext, p->start_addr, p->length);
    198194                mbr_set_flag(p, ST_LOGIC, false);
    199195                rc = mbr_add_partition(label, p);
     
    207203                if (rc_ext) {
    208204                        ext = p;
    209                         printf("ext: %u %u\n", p->start_addr, p->length);
    210205                        label->parts->l_extended = &p->link;
    211206                }
     
    231226int mbr_write_partitions(mbr_label_t *label, service_id_t dev_handle)
    232227{
     228        if (label->parts == NULL)
     229                return EOK;
     230       
     231        if (label->mbr == NULL)
     232                label->mbr = mbr_alloc_mbr();
     233       
    233234        int i = 0;
    234235        int rc;
     
    248249        for (i = 0; i < N_PRIMARY; i++) {
    249250                p = list_get_instance(l, mbr_part_t, link);     
    250                 printf("status: %hu\n", p->status);
    251251                encode_part(p, &(label->mbr->raw_data.pte[i]), 0, false);
    252252                l = l->next;
Note: See TracChangeset for help on using the changeset viewer.