Changeset 0435fe41 in mainline


Ignore:
Timestamp:
2013-08-27T00:32:08Z (11 years ago)
Author:
Dominik Taborsky (AT DOT) <brembyseznamcz>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
61ab4a9, 802898f
Parents:
493b881
Message:

polishing libmbr, libgpt, hdisk

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • tools/toolchain.sh

    • Property mode changed from 100644 to 100755
  • uspace/app/hdisk/func_gpt.c

    r493b881 r0435fe41  
    3838#include <str_error.h>
    3939#include <sys/types.h>
     40#include <sys/typefmt.h>
    4041
    4142#include "func_gpt.h"
     
    110111        size_t i = 0;
    111112       
    112         gpt_part_foreach(this->data.gpt, iter) {
     113        gpt_part_foreach (this->data.gpt, iter) {
    113114                i++;
    114115               
     
    120121               
    121122               
    122                 printf("%3u  %10llu %10llu %10llu    %3d %s\n", i-1, gpt_get_start_lba(iter), gpt_get_end_lba(iter),
    123                                 gpt_get_end_lba(iter) - gpt_get_start_lba(iter), gpt_get_part_type(iter),
    124                                 gpt_get_part_name(iter));
     123                printf("%3zu  %10" PRIu64 " %10" PRIu64 " %10" PRIu64 "    %3zu %s\n",
     124                   i-1, gpt_get_start_lba(iter), gpt_get_end_lba(iter),
     125                        gpt_get_end_lba(iter) - gpt_get_start_lba(iter),
     126                        gpt_get_part_type(iter), gpt_get_part_name(iter));
    125127               
    126128        }
     
    195197        gpt_set_end_lba(p, ea);
    196198       
    197         //printf("Set type : ");
    198         //size_t idx = get_input_size_t(in);
    199         //gpt_set_part_type(p, idx);
     199        /* See global.c from libgpt for all partition types. */
     200        printf("Set type (1 for HelenOS System): ");
     201        size_t idx = get_input_size_t(in);
     202        gpt_set_part_type(p, idx);
    200203       
    201204        gpt_set_random_uuid(p->part_type);
  • uspace/app/hdisk/func_mbr.c

    r493b881 r0435fe41  
    8888       
    8989        rc = mbr_remove_partition(this->data.mbr, idx);
    90         if(rc != EOK) {
     90        if (rc != EOK) {
    9191                printf("Error: something.\n");
    9292        }
     
    116116       
    117117        printf("Current partition scheme (MBR):\n");
    118         //printf("\t\tBootable:\tStart:\tEnd:\tLength:\tType:\n");
    119118        printf("\t\t%10s  %10s %10s %10s %7s\n", "Bootable:", "Start:", "End:", "Length:", "Type:");
    120119       
    121120        mbr_part_t *it;
    122         //mbr_part_foreach(data->mbr, it) {
    123121       
    124122        for (it = mbr_get_first_partition(this->data.mbr); it != NULL;
     
    135133                printf("\t%10u %10u %10u %7u\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
    136134               
    137                 //++num;
    138135        }
    139136       
     
    185182        printf("%c\n", c);
    186183
    187         switch(c) {
    188                 case 'p':
    189                         mbr_set_flag(p, ST_LOGIC, false);
    190                         break;
    191                 case 'l':
    192                         mbr_set_flag(p, ST_LOGIC, true);
    193                         break;
    194                 default:
    195                         printf("Invalid type. Cancelled.\n");
    196                         return EINVAL;
     184        switch (c) {
     185        case 'p':
     186                mbr_set_flag(p, ST_LOGIC, false);
     187                break;
     188        case 'l':
     189                mbr_set_flag(p, ST_LOGIC, true);
     190                break;
     191        default:
     192                printf("Invalid type. Cancelled.\n");
     193                return EINVAL;
    197194        }
    198195       
     
    232229                return errno;
    233230       
    234         /* Align ending address, not in use */
    235         /*if (alignment != 0 && alignment != 1) {
    236                 ea = mbr_get_next_aligned(ea, alignment) - alignment;
    237                 printf("Starting address was aligned to %u.\n", ea);
    238         }*/
    239        
    240         if(ea < sa) {
     231        if (ea < sa) {
    241232                printf("Invalid value. Canceled.\n");
    242233                return EINVAL;
  • uspace/app/hdisk/hdisk.c

    r493b881 r0435fe41  
    8484        init_label();
    8585       
    86         /*
    87         mbr_t * mbr = mbr_read_mbr(dev_handle);
    88         if(mbr == NULL) {
    89                 printf("Failed to read the Master Boot Record.\n"       \
    90                            "Either memory allocation or disk access failed. Exiting.\n");
    91                 return -1;
    92         }
    93 
    94         if(mbr_is_mbr(mbr)) {
    95                 label.layout = LYT_MBR;
    96                 set_label_mbr(mbr);
    97                 mbr_partitions_t * parts = mbr_read_partitions(mbr);
    98                 if(parts == NULL) {
    99                         printf("Failed to read and parse partitions.\n" \
    100                                    "Creating new partition table.");
    101                         parts = mbr_alloc_partitions();
    102                 }
    103                 set_label_mbr_parts(parts);
    104                 fill_label_funcs();
    105                 goto interact;
    106         }
    107        
    108        
    109         mbr_free_mbr(mbr);*/
    110        
    11186        rc = try_read_mbr(dev_handle);
    11287        if (rc == EOK)
    11388                goto interact;
    114        
    115         /*
    116         gpt_t * gpt = gpt_read_gpt_header(dev_handle);
    117        
    118         if(gpt != NULL) {
    119                 label.layout = LYT_GPT;
    120                 set_label_gpt(gpt);
    121                
    122                 gpt_partitions_t * parts = gpt_read_partitions(gpt);
    123                
    124                 if(parts == NULL) {
    125                         printf("Failed to read and parse partitions.\n" \
    126                                    "Creating new partition table.");
    127                         parts = gpt_alloc_partitions();
    128                 }
    129                 set_label_gpt_parts(parts);
    130                 fill_label_funcs();
    131                 goto interact;
    132         }
    133         */
    13489       
    13590        rc = try_read_gpt(dev_handle);
     
    167122                printf("%c\n", input);
    168123               
    169                 switch(input) {
    170                         case 'a':
    171                                 label.add_part(&label, in);
    172                                 break;
    173                         case 'd':
    174                                 label.delete_part(&label, in);
    175                                 break;
    176                         case 'e':
    177                                 label.extra_funcs(&label, in, dev_handle);
    178                                 break;
    179                         case 'f':
    180                                 select_label_format(in);
    181                                 break;
    182                         case 'h':
    183                                 print_help();
    184                                 break;
    185                         case 'l':
    186                                 set_alignment(in);
    187                                 break;
    188                         case 'n':
    189                                 printf("Discarding label...\n");
    190                                 free_label();
    191                                 label.new_label(&label);
    192                                 break;
    193                         case 'p':
    194                                 label.print_parts(&label);
    195                                 break;
    196                         case 'q':
    197                                 putchar('\n');
    198                                 free_label();
    199                                 goto end;
    200                         case 'r':
    201                                 label.read_parts(&label, dev_handle);
    202                         case 'w':
    203                                 label.write_parts(&label, dev_handle);
    204                                 break;
    205                         default:
    206                                 printf("Unknown command. Try 'h' for help.\n");
    207                                 break;
     124                switch (input) {
     125                case 'a':
     126                        label.add_part(&label, in);
     127                        break;
     128                case 'd':
     129                        label.delete_part(&label, in);
     130                        break;
     131                case 'e':
     132                        label.extra_funcs(&label, in, dev_handle);
     133                        break;
     134                case 'f':
     135                        select_label_format(in);
     136                        break;
     137                case 'h':
     138                        print_help();
     139                        break;
     140                case 'l':
     141                        set_alignment(in);
     142                        break;
     143                case 'n':
     144                        printf("Discarding label...\n");
     145                        free_label();
     146                        label.new_label(&label);
     147                        break;
     148                case 'p':
     149                        label.print_parts(&label);
     150                        break;
     151                case 'q':
     152                        putchar('\n');
     153                        free_label();
     154                        goto end;
     155                case 'r':
     156                        label.read_parts(&label, dev_handle);
     157                case 'w':
     158                        label.write_parts(&label, dev_handle);
     159                        break;
     160                default:
     161                        printf("Unknown command. Try 'h' for help.\n");
     162                        break;
    208163                }
    209164        }
     
    241196       
    242197        uint8_t val = get_input_uint8(in);
    243         switch(val) {
    244                 case 0:
    245                         free_label();
    246                         construct_label(LYT_NONE);
    247                         break;
    248                 case 1:
    249                         free_label();
    250                         construct_label(LYT_MBR);
    251                         break;
    252                 case 2:
    253                         free_label();
    254                         construct_label(LYT_GPT);
    255                         break;
     198        switch (val) {
     199        case 0:
     200                free_label();
     201                construct_label(LYT_NONE);
     202                break;
     203        case 1:
     204                free_label();
     205                construct_label(LYT_MBR);
     206                break;
     207        case 2:
     208                free_label();
     209                construct_label(LYT_GPT);
     210                break;
    256211        }
    257212}
     
    259214void construct_label(layouts_t layout)
    260215{
    261         switch(layout) {
    262                 case LYT_MBR:
    263                         label.layout = LYT_MBR;
    264                         construct_mbr_label(&label);
    265                         break;
    266                 case LYT_GPT:
    267                         label.layout = LYT_GPT;
    268                         construct_gpt_label(&label);
    269                         break;
    270                 default:
    271                         label.layout = LYT_NONE;
    272                         construct_none_label(&label);
    273                         break;
     216        switch (layout) {
     217        case LYT_MBR:
     218                label.layout = LYT_MBR;
     219                construct_mbr_label(&label);
     220                break;
     221        case LYT_GPT:
     222                label.layout = LYT_GPT;
     223                construct_gpt_label(&label);
     224                break;
     225        default:
     226                label.layout = LYT_NONE;
     227                construct_none_label(&label);
     228                break;
    274229        }
    275230}
     
    306261
    307262
    308 
    309 
    310 
    311 
    312 
    313 
    314 
  • uspace/app/hdisk/input.c

    r493b881 r0435fe41  
    6868        int rc;
    6969        uint32_t val;
    70         /*char * str;
    71        
    72         rc = get_input_line(in, &str);
    73         if (rc != EOK) {
    74                 printf("Error reading input.\n");
    75                 return 0;
    76         }
    77        
    78         rc = str_uint8_t(str, NULL, 10, true, &val);
    79         if( != EOK) {
    80                 printf("Invalid value.\n");
    81                 return 0;
    82         }
    83        
    84         free(str);*/
    8570       
    8671        rc = convert(in, (conv_f) str_uint8_t, &val);
     
    9782        int rc;
    9883        uint32_t val;
    99         /*char * str;
    100        
    101         rc = get_input_line(in, &str);
    102         if (rc != EOK) {
    103                 printf("Error reading input.\n");
    104                 return 0;
    105         }
    106        
    107         rc = str_uint32_t(str, NULL, 10, true, &val);
    108         if( != EOK) {
    109                 printf("Invalid value.\n");
    110                 return 0;
    111         }
    112        
    113         free(str);*/
    11484       
    11585        rc = convert(in, (conv_f) str_uint32_t, &val);
     
    12696        int rc;
    12797        uint64_t val;
    128         /*char * str;
    129        
    130         rc = get_input_line(in, &str);
    131         if (rc != EOK) {
    132                 printf("Error reading input.\n");
    133                 return 0;
    134         }
    135        
    136         rc = str_uint32_t(str, NULL, 10, true, &val);
    137         if( != EOK) {
    138                 printf("Invalid value.\n");
    139                 return 0;
    140         }
    141        
    142         free(str);*/
    14398       
    14499        rc = convert(in, (conv_f) str_uint64_t, &val);
     
    155110        int rc;
    156111        size_t val;
    157        
    158         /*char * str;
    159         rc = get_input_line(in, &str);
    160         if (rc != EOK) {
    161                 printf("Error reading input.\n");
    162                 return 0;
    163         }
    164        
    165         rc = str_size_t(str, NULL, 10, true, &val);
    166         if (rc != EOK) {
    167                 printf("Invalid value.\n");
    168                 return 0;
    169         }
    170         free(str);*/
    171112       
    172113        rc = convert(in, (conv_f) str_size_t, &val);
     
    192133       
    193134        rc = str_f(str, NULL, 10, true, val);
    194         if(rc != EOK) {
     135        if (rc != EOK) {
    195136                printf("Invalid value.\n");
    196137        }
  • uspace/lib/gpt/global.c

    r493b881 r0435fe41  
    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" },
     43        { "Unused entry",                                       "00000000" "0000" "0000" "0000000000000000" }, /* 0 */
     44        { "HelenOS System",                                     "656C6548" "4F6E" "5320" "53797374656D0000" }, /* 1 It says "HelenOS System\0\0" */
     45        { "MBR partition scheme",                       "024DEE41" "33E7" "11D3" "9D690008C781F39F" },
     46        { "EFI System",                                         "C12A7328" "F81F" "11D2" "BA4B00A0C93EC93B" },
     47        { "BIOS Boot",                                          "21686148" "6449" "6E6F" "744E656564454649" },
     48        { "Windows Reserved",                           "E3C9E316" "0B5C" "4DB8" "817DF92DF00215AE" },
     49        { "Windows Basic data",                         "EBD0A0A2" "B9E5" "4433" "87C068B6B72699C7" },
     50        { "Windows LDM metadata",                       "5808C8AA" "7E8F" "42E0" "85D2E1E90434CFB3" },
     51        { "Windows LDM data",                           "AF9B60A0" "1431" "4F62" "BC683311714A69AD" },
     52        { "Windows Recovery Environment",       "DE94BBA4" "06D1" "4D40" "A16ABFD50179D6AC" },
     53        { "Windows IBM GPFS",                           "37AFFC90" "EF7D" "4E96" "91C32D7AE055B174" }, /* 10 */
     54        { "Windows Cluster metadata",           "DB97DBA9" "0840" "4BAE" "97F0FFB9A327C7E1" },
     55        { "HP-UX Data",                                         "75894C1E" "3AEB" "11D3" "B7C17B03A0000000" },
     56        { "HP-UX Service",                                      "E2A1E728" "32E3" "11D6" "A6827B03A0000000" },
     57        { "Linux filesystem data",                      "EBD0A0A2" "B9E5" "4433" "87C068B6B72699C7" },
     58        { "Linux filesystem data",                      "0FC63DAF" "8483" "4772" "8E793D69D8477DE4" },
     59        { "Linux RAID",                                         "A19D880F" "05FC" "4D3B" "A006743F0F84911E" },
     60        { "Linux Swap",                                         "0657FD6D" "A4AB" "43C4" "84E50933C84B4F4F" },
     61        { "Linux LVM",                                          "E6D6D379" "F507" "44C2" "A23C238F2A3DF928" },
     62        { "Linux Reserved",                                     "8DA63339" "0007" "60C0" "C436083AC8230908" },
     63        { "FreeBSD Boot",                                       "83BD6B9D" "7F41" "11DC" "BE0B001560B84F0F" }, /* 20 */
     64        { "FreeBSD Data",                                       "516E7CB4" "6ECF" "11D6" "8FF800022D09712B" },
     65        { "FreeBSD Swap",                                       "516E7CB5" "6ECF" "11D6" "8FF800022D09712B" },
     66        { "FreeBSD UFS",                                        "516E7CB6" "6ECF" "11D6" "8FF800022D09712B" },
     67        { "FreeBSD Vinum VM",                           "516E7CB8" "6ECF" "11D6" "8FF800022D09712B" },
     68        { "FreeBSD ZFS",                                        "516E7CBA" "6ECF" "11D6" "8FF800022D09712B" },
     69        { "Mac OS X HFS+",                                      "48465300" "0000" "11AA" "AA1100306543ECAC" },
     70        { "Mac OS X UFS",                                       "55465300" "0000" "11AA" "AA1100306543ECAC" },
     71        { "Mac OS X ZFS",                                       "6A898CC3" "1DD2" "11B2" "99A6080020736631" },
     72        { "Mac OS X RAID",                                      "52414944" "0000" "11AA" "AA1100306543ECAC" },
     73        { "Mac OS X RAID, offline",                     "52414944" "5F4F" "11AA" "AA1100306543ECAC" }, /* 30 */
     74        { "Mac OS X Boot",                                      "426F6F74" "0000" "11AA" "AA1100306543ECAC" },
     75        { "Mac OS X Label",                                     "4C616265" "6C00" "11AA" "AA1100306543ECAC" },
     76        { "Mac OS X TV Recovery",                       "5265636F" "7665" "11AA" "AA1100306543ECAC" },
     77        { "Mac OS X Core Storage",                      "53746F72" "6167" "11AA" "AA1100306543ECAC" },
     78        { "Solaris Boot",                                       "6A82CB45" "1DD2" "11B2" "99A6080020736631" },
     79        { "Solaris Root",                                       "6A85CF4D" "1DD2" "11B2" "99A6080020736631" },
     80        { "Solaris Swap",                                       "6A87C46F" "1DD2" "11B2" "99A6080020736631" },
     81        { "Solaris Backup",                                     "6A8B642B" "1DD2" "11B2" "99A6080020736631" },
     82        { "Solaris /usr",                                       "6A898CC3" "1DD2" "11B2" "99A6080020736631" },
     83        { "Solaris /var",                                       "6A8EF2E9" "1DD2" "11B2" "99A6080020736631" }, /* 40 */
     84        { "Solaris /home",                                      "6A90BA39" "1DD2" "11B2" "99A6080020736631" },
     85        { "Solaris Alternate sector",           "6A9283A5" "1DD2" "11B2" "99A6080020736631" },
     86        { "Solaris Reserved",                           "6A945A3B" "1DD2" "11B2" "99A6080020736631" },
     87        { "Solaris Reserved",                           "6A9630D1" "1DD2" "11B2" "99A6080020736631" },
     88        { "Solaris Reserved",                           "6A980767" "1DD2" "11B2" "99A6080020736631" },
     89        { "Solaris Reserved",                           "6A96237F" "1DD2" "11B2" "99A6080020736631" },
     90        { "Solaris Reserved",                           "6A8D2AC7" "1DD2" "11B2" "99A6080020736631" },
     91        { "NetBSD Swap",                                        "49F48D32" "B10E" "11DC" "B99B0019D1879648" },
     92        { "NetBSD FFS",                                         "49F48D5A" "B10E" "11DC" "B99B0019D1879648" },
     93        { "NetBSD LFS",                                         "49F48D82" "B10E" "11DC" "B99B0019D1879648" }, /* 50 */
     94        { "NetBSD RAID",                                        "49F48DAA" "B10E" "11DC" "B99B0019D1879648" },
     95        { "NetBSD Concatenated",                        "2DB519C4" "B10F" "11DC" "B99B0019D1879648" },
     96        { "NetBSD Encrypted",                           "2DB519EC" "B10F" "11DC" "B99B0019D1879648" },
     97        { "ChromeOS ChromeOS kernel",           "FE3A2A5D" "4F32" "41A7" "B725ACCC3285A309" },
     98        { "ChromeOS rootfs",                            "3CB8E202" "3B7E" "47DD" "8A3C7FF2A13CFCEC" },
     99        { "ChromeOS future use",                        "2E0A753D" "9E48" "43B0" "8337B15192CB1B5E" },
     100        { "MidnightBSD Boot",                           "85D5E45E" "237C" "11E1" "B4B3E89A8F7FC3A7" },
     101        { "MidnightBSD Data",                           "85D5E45A" "237C" "11E1" "B4B3E89A8F7FC3A7" },
     102        { "MidnightBSD Swap",                           "85D5E45B" "237C" "11E1" "B4B3E89A8F7FC3A7" },
     103        { "MidnightBSD UFS",                            "0394Ef8B" "237E" "11E1" "B4B3E89A8F7FC3A7" }, /* 60 */
     104        { "MidnightBSD Vinum VM",                       "85D5E45C" "237C" "11E1" "B4B3E89A8F7FC3A7" },
     105        { "MidnightBSD ZFS",                            "85D5E45D" "237C" "11E1" "B4B3E89A8F7FC3A7" },
    105106        { "Uknown", NULL} /* keep this as the last one! gpt_get_part_type depends on it! */
    106107};
  • uspace/lib/gpt/libgpt.c

    r493b881 r0435fe41  
    4848#include <checksum.h>
    4949#include <mem.h>
     50#include <sys/typefmt.h>
     51
    5052
    5153#include "libgpt.h"
     
    5557static int extend_part_array(gpt_partitions_t *);
    5658static int reduce_part_array(gpt_partitions_t *);
    57 //static long long nearest_larger_int(double);
    5859static uint8_t get_byte(const char *);
    5960static bool check_overlap(gpt_part_t *, gpt_part_t *);
     
    313314                           fillries * ent_size);
    314315
    315         if(uint32_t_le2host(label->gpt->header->pe_array_crc32) != crc)
     316        if (uint32_t_le2host(label->gpt->header->pe_array_crc32) != crc)
    316317        {
    317318                rc = EBADCHECKSUM;
     
    369370       
    370371        /* Perform checks */
    371         gpt_part_foreach(label, p) {
     372        gpt_part_foreach (label, p) {
    372373                if (gpt_get_part_type(p) == GPT_PTE_UNUSED)
    373374                        continue;
     
    375376                if (!check_encaps(p, n_blocks, gpt_space)) {
    376377                        rc = ERANGE;
    377                         printf("encaps with: %llu, %llu, %llu\n", n_blocks, gpt_space, gpt_get_end_lba(p));
     378                        printf("encaps with: %" PRIuOFF64 ", %" PRIu64 ", %" PRIu64 "\n",
     379                            n_blocks, gpt_space, gpt_get_end_lba(p));
    378380                        goto fail;
    379381                }
    380382               
    381                 gpt_part_foreach(label, q) {
     383                gpt_part_foreach (label, q) {
    382384                        if (p == q)
    383385                                continue;
     
    385387                        if (gpt_get_part_type(p) != GPT_PTE_UNUSED) {
    386388                                if (check_overlap(p, q)) {
    387                                         printf("overlap with: %llu, %llu\n", gpt_get_start_lba(p), gpt_get_start_lba(q));
     389                                        printf("overlap with: %" PRIu64 ", %" PRIu64 "\n",
     390                                            gpt_get_start_lba(p), gpt_get_start_lba(q));
    388391                                        rc = ERANGE;
    389392                                        goto fail;
     
    709712void gpt_set_random_uuid(uint8_t * uuid)
    710713{
    711         srandom((unsigned int) uuid);
     714        srandom((unsigned int) (size_t) uuid);
    712715       
    713716        unsigned int i;
     
    786789        size_t nsize = p->arr_size * 2;
    787790        gpt_entry_t * tmp = malloc(nsize * sizeof(gpt_entry_t));
    788         if(tmp == NULL) {
     791        if (tmp == NULL) {
    789792                errno = ENOMEM;
    790793                return -1;
     
    801804static int reduce_part_array(gpt_partitions_t * p)
    802805{
    803         if(p->arr_size > GPT_MIN_PART_NUM) {
     806        if (p->arr_size > GPT_MIN_PART_NUM) {
    804807                unsigned int nsize = p->arr_size / 2;
    805808                nsize = nsize > GPT_MIN_PART_NUM ? nsize : GPT_MIN_PART_NUM;
    806809                gpt_entry_t * tmp = malloc(nsize * sizeof(gpt_entry_t));
    807                 if(tmp == NULL)
     810                if (tmp == NULL)
    808811                        return ENOMEM;
    809812
     
    816819        return 0;
    817820}
    818 
    819 /*static long long nearest_larger_int(double a)
    820 {
    821         if ((long long) a == a) {
    822                 return (long long) a;
    823         }
    824 
    825         return ((long long) a) + 1;
    826 }*/
    827821
    828822/* Parse a byte from a string in hexadecimal
  • uspace/lib/mbr/libmbr.c

    r493b881 r0435fe41  
    170170        mbr_part_t *p;
    171171        mbr_part_t *ext = NULL;
    172         //mbr_partitions_t *parts;
    173172       
    174173        if (label->parts != NULL)
     
    598597}
    599598
    600 // Internal functions follow //
     599/* Internal functions follow */
    601600
    602601static br_block_t *alloc_br()
     
    732731{
    733732        if (src != NULL) {
    734                 //trgt->status = mbr_get_flag(src, ST_BOOT) ? B_ACTIVE : B_INACTIVE;
    735733                trgt->status = (uint8_t) (src->status & 0xFF);
    736734                /* ingoring CHS */
     
    741739                trgt->last_chs[1] = 0xFF;
    742740                trgt->last_chs[2] = 0xFF;
    743                 if (ebr) {      // encoding reference to EBR
     741                if (ebr) {      /* encoding reference to EBR */
    744742                        trgt->ptype = PT_EXTENDED_LBA;
    745743                        trgt->first_lba = host2uint32_t_le(src->ebr_addr - base);
    746744                        trgt->length = host2uint32_t_le(src->length + src->start_addr - src->ebr_addr);
    747                 } else {        // encoding reference to partition
     745                } else {        /* encoding reference to partition */
    748746                        trgt->ptype = src->type;
    749747                        trgt->first_lba = host2uint32_t_le(src->start_addr - base);
     
    850848        bool first_logical = true;
    851849        mbr_part_t *iter;
    852         mbr_part_foreach(label, iter) {
     850        mbr_part_foreach (label, iter) {
    853851                if (mbr_get_flag(iter, ST_LOGIC)) {
    854852                        if (check_overlap(p, iter))
Note: See TracChangeset for help on using the changeset viewer.