Changeset 0435fe41 in mainline for uspace/app


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

polishing libmbr, libgpt, hdisk

Location:
uspace/app/hdisk
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • 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        }
Note: See TracChangeset for help on using the changeset viewer.