Changeset 6e8e4e19 in mainline for uspace/app


Ignore:
Timestamp:
2013-06-16T14:50:59Z (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:
1c8bfe8
Parents:
c9f61150
Message:

libmbr & hdisk changes, fixes, updates

Location:
uspace/app/hdisk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hdisk/common.h

    rc9f61150 r6e8e4e19  
    3939#include <libgpt.h>
    4040
     41typedef enum {
     42        LYT_NONE,
     43        LYT_MBR,
     44        LYT_GPT,
     45} layouts_t;
     46
    4147union label_data {
    4248        mbr_label_t     *mbr;
    … …  
    4450};
    4551
     52typedef struct label label_t;
     53
     54struct label {
     55        layouts_t layout;
     56        union label_data data;
     57        unsigned int alignment;
     58        int (* destroy_label)(label_t *);
     59        int (* add_part)     (label_t *, tinput_t *);
     60        int (* delete_part)  (label_t *, tinput_t *);
     61        int (* new_label)    (label_t *);
     62        int (* print_parts)  (label_t *);
     63        int (* read_parts)   (label_t *, service_id_t);
     64        int (* write_parts)  (label_t *, service_id_t);
     65        int (* extra_funcs)  (label_t *, tinput_t *, service_id_t);
     66};
     67
    4668#endif
    4769

  • uspace/app/hdisk/func_gpt.c

    rc9f61150 r6e8e4e19  
    4343static int set_gpt_partition(tinput_t *, gpt_part_t *);
    4444
    45 int add_gpt_part(tinput_t * in, union label_data * data)
     45
     46int construct_gpt_label(label_t *this)
    4647{
    47         gpt_part_t * p = gpt_alloc_partition(data->gpt->parts);
     48        this->layout = LYT_GPT;
     49        this->alignment = 1;
     50       
     51        this->add_part    = add_gpt_part;
     52        this->delete_part = delete_gpt_part;
     53        this->new_label   = new_gpt_label;
     54        this->print_parts = print_gpt_parts;
     55        this->read_parts  = read_gpt_parts;
     56        this->write_parts = write_gpt_parts;
     57        this->extra_funcs = extra_gpt_funcs;
     58       
     59        return this->new_label(this);
     60}
     61
     62int add_gpt_part(label_t *this, tinput_t * in)
     63{
     64        gpt_part_t * p = gpt_alloc_partition(this->data.gpt->parts);
    4865        if (p == NULL) {
    4966                return ENOMEM;
    … …  
    5370}
    5471
    55 int delete_gpt_part(tinput_t * in, union label_data * data)
     72int delete_gpt_part(label_t *this, tinput_t * in)
    5673{
    5774        size_t idx;
    … …  
    6077        idx = get_input_size_t(in);
    6178
    62         if (gpt_remove_partition(data->gpt->parts, idx) == -1) {
     79        if (gpt_remove_partition(this->data.gpt->parts, idx) == -1) {
    6380                printf("Warning: running low on memory, not resizing...\n");
    6481        }
    … …  
    6784}
    6885
    69 int destroy_gpt_label(union label_data *data)
     86int destroy_gpt_label(label_t *this)
    7087{
    7188        return EOK;
    7289}
    7390
    74 int new_gpt_label(union label_data *data)
     91int new_gpt_label(label_t *this)
    7592{
    76         data->gpt->gpt = gpt_alloc_gpt_header();
    77         data->gpt->parts = gpt_alloc_partitions();
     93        this->data.gpt->gpt = gpt_alloc_gpt_header();
     94        this->data.gpt->parts = gpt_alloc_partitions();
    7895        return EOK;
    7996}
    8097
    81 int print_gpt_parts(union label_data *data)
     98int print_gpt_parts(label_t *this)
    8299{
    83100        //int rc;
    … …  
    87104        size_t i = 0;
    88105       
    89         gpt_part_foreach(data->gpt->parts, iter) {
     106        gpt_part_foreach(this->data.gpt->parts, iter) {
     107                //FIXMEE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     108                if (gpt_get_part_type(iter) == 62)
     109                        continue;
     110               
    90111                //printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
    91112                //              iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
    … …  
    100121}
    101122
    102 int read_gpt_parts(service_id_t dev_handle, union label_data *data)
     123int read_gpt_parts(label_t *this, service_id_t dev_handle)
    103124{
    104125        return EOK;
    105126}
    106127
    107 int write_gpt_parts(service_id_t dev_handle, union label_data * data)
     128int write_gpt_parts(label_t *this, service_id_t dev_handle)
    108129{
    109130        int rc;
    110131
    111         rc = gpt_write_partitions(data->gpt->parts, data->gpt->gpt, dev_handle);
     132        rc = gpt_write_partitions(this->data.gpt->parts, this->data.gpt->gpt, dev_handle);
    112133        if (rc != EOK) {
    113134                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    … …  
    115136        }
    116137
    117         rc = gpt_write_gpt_header(data->gpt->gpt, dev_handle);
     138        rc = gpt_write_gpt_header(this->data.gpt->gpt, dev_handle);
    118139        if (rc != EOK) {
    119140                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    … …  
    124145}
    125146
    126 int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union label_data * data)
     147int extra_gpt_funcs(label_t *this, tinput_t * in, service_id_t dev_handle)
    127148{
    128149        printf("Not implemented.\n");

  • uspace/app/hdisk/func_gpt.h

    rc9f61150 r6e8e4e19  
    4242#include "common.h"
    4343
    44 extern int add_gpt_part(tinput_t *, union label_data *);
    45 extern int delete_gpt_part(tinput_t *, union label_data *);
    46 extern int destroy_gpt_label(union label_data *);
    47 extern int new_gpt_label(union label_data *);
    48 extern int print_gpt_parts(union label_data *);
    49 extern int read_gpt_parts(service_id_t, union label_data *);
    50 extern int write_gpt_parts(service_id_t, union label_data *);
    51 extern int extra_gpt_funcs(tinput_t *, service_id_t, union label_data *);
     44extern int construct_gpt_label(label_t *);
     45extern int add_gpt_part     (label_t *, tinput_t *);
     46extern int delete_gpt_part  (label_t *, tinput_t *);
     47extern int destroy_gpt_label(label_t *);
     48extern int new_gpt_label    (label_t *);
     49extern int print_gpt_parts  (label_t *);
     50extern int read_gpt_parts   (label_t *, service_id_t);
     51extern int write_gpt_parts  (label_t *, service_id_t);
     52extern int extra_gpt_funcs  (label_t *, tinput_t *, service_id_t);
    5253
    5354#endif

  • uspace/app/hdisk/func_mbr.c

    rc9f61150 r6e8e4e19  
    4141#include "input.h"
    4242
    43 static int set_mbr_partition(tinput_t *in, mbr_part_t *p);
    44 
    45 int add_mbr_part(tinput_t *in, union label_data *data)
     43static int set_mbr_partition(tinput_t *in, mbr_part_t *p, unsigned int alignment);
     44
     45int construct_mbr_label(label_t *this)
     46{
     47        this->layout = LYT_MBR;
     48        this->alignment = 1;
     49       
     50        this->add_part      = add_mbr_part;
     51        this->delete_part   = delete_mbr_part;
     52        this->destroy_label = destroy_mbr_label;
     53        this->new_label     = new_mbr_label;
     54        this->print_parts   = print_mbr_parts;
     55        this->read_parts    = read_mbr_parts;
     56        this->write_parts   = write_mbr_parts;
     57        this->extra_funcs   = extra_mbr_funcs;
     58       
     59        return this->new_label(this);
     60}
     61
     62int add_mbr_part(label_t *this, tinput_t *in)
    4663{
    4764        int rc;
    4865       
    4966        mbr_part_t *part = mbr_alloc_partition();
    50 
    51         set_mbr_partition(in, part);
    52 
    53         rc = mbr_add_partition(data->mbr, part);
    54         if (rc != EOK) {
    55                 printf("Error adding partition.\n");
    56         }
    57        
    58         return EOK;
    59 }
    60 
    61 int delete_mbr_part(tinput_t *in, union label_data *data)
     67       
     68        set_mbr_partition(in, part, this->alignment);
     69       
     70        rc = mbr_add_partition(this->data.mbr, part);
     71        if (rc != ERR_OK) {
     72                printf("Error adding partition: %d\n", rc);
     73        }
     74       
     75        return EOK;
     76}
     77
     78int delete_mbr_part(label_t *this, tinput_t *in)
    6279{
    6380        int rc;
    6481        size_t idx;
    65 
     82       
    6683        printf("Number of the partition to delete (counted from 0): ");
    6784        idx = get_input_size_t(in);
    … …  
    7087                return errno;
    7188       
    72         rc = mbr_remove_partition(data->mbr, idx);
     89        rc = mbr_remove_partition(this->data.mbr, idx);
    7390        if(rc != EOK) {
    7491                printf("Error: something.\n");
    7592        }
    76 
    77         return EOK;
    78 }
    79 
    80 int destroy_mbr_label(union label_data *data)
    81 {
    82         mbr_free_label(data->mbr);
    83         return EOK;
    84 }
    85 
    86 int new_mbr_label(union label_data *data)
    87 {
    88         data->mbr = mbr_alloc_label();
    89         if (data->mbr == NULL)
     93       
     94        return EOK;
     95}
     96
     97int destroy_mbr_label(label_t *this)
     98{
     99        mbr_free_label(this->data.mbr);
     100        return EOK;
     101}
     102
     103int new_mbr_label(label_t *this)
     104{
     105        this->data.mbr = mbr_alloc_label();
     106        if (this->data.mbr == NULL)
    90107                return ENOMEM;
    91108        else
    … …  
    94111
    95112/** Print current partition scheme */
    96 int print_mbr_parts(union label_data *data)
     113int print_mbr_parts(label_t *this)
    97114{
    98115        int num = 0;
    99 
    100         printf("Current partition scheme:\n");
     116       
     117        printf("Current partition scheme (MBR):\n");
    101118        //printf("\t\tBootable:\tStart:\tEnd:\tLength:\tType:\n");
    102119        printf("\t\t%10s  %10s %10s %10s %7s\n", "Bootable:", "Start:", "End:", "Length:", "Type:");
    103120       
    104121        mbr_part_t *it;
    105         mbr_part_foreach(data->mbr->parts, it) {
     122        //mbr_part_foreach(data->mbr, it) {
     123       
     124        for (it = mbr_get_first_partition(this->data.mbr); it != NULL;
     125             it = mbr_get_next_partition(this->data.mbr, it), ++num) {
    106126                if (it->type == PT_UNUSED)
    107127                        continue;
    108 
     128               
    109129                printf("\tP%d:\t", num);
    110130                if (mbr_get_flag(it, ST_BOOT))
    … …  
    112132                else
    113133                        printf(" ");
    114 
     134               
    115135                printf("\t%10u %10u %10u %7u\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
    116 
    117                 ++num;
    118         }
    119 
     136               
     137                //++num;
     138        }
     139       
    120140        printf("%d partitions found.\n", num);
    121141       
    … …  
    123143}
    124144
    125 int read_mbr_parts(service_id_t dev_handle, union label_data *data)
     145int read_mbr_parts(label_t *this, service_id_t dev_handle)
    126146{
    127147        int rc;
    128         printf("mbr\n");
    129         rc = mbr_read_mbr(data->mbr, dev_handle);
     148        rc = mbr_read_mbr(this->data.mbr, dev_handle);
    130149        if (rc != EOK)
    131150                return rc;
    132         printf("ismbr\n");
    133         if (!mbr_is_mbr(data->mbr))
     151       
     152        if (!mbr_is_mbr(this->data.mbr))
    134153                return EINVAL;
    135         printf("parts\n");
    136         rc = mbr_read_partitions(data->mbr);
     154       
     155        rc = mbr_read_partitions(this->data.mbr);
    137156        if (rc != EOK)
    138157                return rc;
    139         printf("end\n");
    140         return EOK;
    141 }
    142 
    143 int write_mbr_parts(service_id_t dev_handle, union label_data *data)
    144 {
    145         int rc = mbr_write_partitions(data->mbr, dev_handle);
     158       
     159        return EOK;
     160}
     161
     162int write_mbr_parts(label_t *this, service_id_t dev_handle)
     163{
     164        int rc = mbr_write_partitions(this->data.mbr, dev_handle);
    146165        if (rc != EOK) {
    147166                printf("Error occured during writing: ERR: %d: %s\n", rc, str_error(rc));
    … …  
    151170}
    152171
    153 int extra_mbr_funcs(tinput_t *in, service_id_t dev_handle, union label_data *data)
     172int extra_mbr_funcs(label_t *this, tinput_t *in, service_id_t dev_handle)
    154173{
    155174        printf("Not implemented.\n");
    … …  
    157176}
    158177
    159 static int set_mbr_partition(tinput_t *in, mbr_part_t *p)
     178static int set_mbr_partition(tinput_t *in, mbr_part_t *p, unsigned int alignment)
    160179{
    161180        int c;
    … …  
    174193                        break;
    175194                default:
    176                         printf("Invalid type. Cancelled.");
     195                        printf("Invalid type. Cancelled.\n");
    177196                        return EINVAL;
    178197        }
     198       
     199        printf("ST_LOGIC: %d, %hd\n", mbr_get_flag(p, ST_LOGIC), p->status);
    179200       
    180201        printf("Set type (0-255): ");
    … …  
    200221        if (sa == 0 && errno != EOK)
    201222                return errno;
     223       
     224        if (alignment != 0 && alignment != 1) {
     225                sa = mbr_get_next_aligned(sa, alignment);
     226                printf("Starting address was aligned to %u.\n", sa);
     227        }
    202228
    203229        printf("Set end addres (number): ");
    … …  
    206232                return errno;
    207233       
     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       
    208240        if(ea < sa) {
    209241                printf("Invalid value. Canceled.\n");

  • uspace/app/hdisk/func_mbr.h

    rc9f61150 r6e8e4e19  
    4242#include "common.h"
    4343
    44 extern int add_mbr_part(tinput_t *, union label_data *);
    45 extern int delete_mbr_part(tinput_t *, union label_data *);
    46 extern int destroy_mbr_label(union label_data *);
    47 extern int new_mbr_label(union label_data *);
    48 extern int print_mbr_parts(union label_data *);
    49 extern int read_mbr_parts(service_id_t, union label_data *);
    50 extern int write_mbr_parts(service_id_t, union label_data *);
    51 extern int extra_mbr_funcs(tinput_t *, service_id_t, union label_data *);
     44extern int construct_mbr_label(label_t *);
     45extern int add_mbr_part     (label_t *, tinput_t *);
     46extern int delete_mbr_part  (label_t *, tinput_t *);
     47extern int destroy_mbr_label(label_t *);
     48extern int new_mbr_label    (label_t *);
     49extern int print_mbr_parts  (label_t *);
     50extern int read_mbr_parts   (label_t *, service_id_t);
     51extern int write_mbr_parts  (label_t *, service_id_t);
     52extern int extra_mbr_funcs  (label_t *, tinput_t *, service_id_t);
    5253
    5354#endif

  • uspace/app/hdisk/func_none.c

    rc9f61150 r6e8e4e19  
    4141
    4242
    43 int add_none_part(tinput_t *in, union label_data *data)
     43int construct_none_label(label_t *this)
     44{
     45        this->layout = LYT_NONE;
     46       
     47        this->add_part      = add_none_part;
     48        this->delete_part   = delete_none_part;
     49        this->destroy_label = destroy_none_label;
     50        this->new_label     = new_none_label;
     51        this->print_parts   = print_none_parts;
     52        this->read_parts    = read_none_parts;
     53        this->write_parts   = write_none_parts;
     54        this->extra_funcs   = extra_none_funcs;
     55       
     56        return EOK;
     57}
     58
     59int add_none_part(label_t *this, tinput_t * in)
    4460{
    4561        not_implemented();
    … …  
    4763}
    4864
    49 int delete_none_part(tinput_t *in, union label_data *data)
     65int delete_none_part(label_t *this, tinput_t * in)
    5066{
    5167        not_implemented();
    … …  
    5369}
    5470
    55 int destroy_none_label(union label_data *data)
     71int destroy_none_label(label_t *this)
     72{
     73        return EOK;
     74}
     75
     76int new_none_label(label_t *this)
    5677{
    5778        not_implemented();
    … …  
    5980}
    6081
    61 int new_none_label(union label_data *data)
     82int print_none_parts(label_t *this)
    6283{
    6384        not_implemented();
    … …  
    6586}
    6687
    67 int print_none_parts(union label_data *data)
     88int read_none_parts(label_t *this, service_id_t dev_handle)
    6889{
    6990        not_implemented();
    … …  
    7192}
    7293
    73 int read_none_parts(service_id_t dev_handle, union label_data *data)
     94int write_none_parts(label_t *this, service_id_t dev_handle)
    7495{
    7596        not_implemented();
    … …  
    7798}
    7899
    79 int write_none_parts(service_id_t dev_handle, union label_data *data)
    80 {
    81         not_implemented();
    82         return EOK;
    83 }
    84 
    85 int extra_none_funcs(tinput_t *in, service_id_t dev_handle, union label_data *data)
     100int extra_none_funcs(label_t *this, tinput_t * in, service_id_t dev_handle)
    86101{
    87102        not_implemented();

  • uspace/app/hdisk/func_none.h

    rc9f61150 r6e8e4e19  
    4141#include "common.h"
    4242
    43 extern int add_none_part(tinput_t *, union label_data *);
    44 extern int delete_none_part(tinput_t *, union label_data *);
    45 extern int destroy_none_label(union label_data *);
    46 extern int new_none_label(union label_data *);
    47 extern int print_none_parts(union label_data *);
    48 extern int read_none_parts(service_id_t, union label_data *);
    49 extern int write_none_parts(service_id_t, union label_data *);
    50 extern int extra_none_funcs(tinput_t *, service_id_t, union label_data *);
     43extern int construct_none_label(label_t *);
     44extern int add_none_part     (label_t *, tinput_t *);
     45extern int delete_none_part  (label_t *, tinput_t *);
     46extern int destroy_none_label(label_t *);
     47extern int new_none_label    (label_t *);
     48extern int print_none_parts  (label_t *);
     49extern int read_none_parts   (label_t *, service_id_t);
     50extern int write_none_parts  (label_t *, service_id_t);
     51extern int extra_none_funcs  (label_t *, tinput_t *, service_id_t);
    5152
    5253#endif

  • uspace/app/hdisk/hdisk.c

    rc9f61150 r6e8e4e19  
    5656void print_help(void);
    5757void select_label_format(tinput_t *);
    58 void fill_label_funcs(void);
     58void construct_label(layouts_t);
    5959void free_label(void);
    6060int try_read(service_id_t);
    61 
    62 int construct_none_label(void);
    63 
    64 int construct_mbr_label(void);
    6561int try_read_mbr(service_id_t);
    66 
    67 int construct_gpt_label(void);
    6862int try_read_gpt(service_id_t);
     63void set_alignment(tinput_t *);
    6964
    7065
    … …  
    8782        }
    8883       
    89         printf("Init.\n");
    9084        init_label();
    9185       
    … …  
    115109        mbr_free_mbr(mbr);*/
    116110       
    117         printf("Try MBR.\n");
    118111        rc = try_read_mbr(dev_handle);
    119112        if (rc == EOK)
    … …  
    140133        */
    141134       
    142         printf("Try GPT.\n");
    143135        rc = try_read_gpt(dev_handle);
    144136        if (rc == EOK)
    … …  
    149141       
    150142interact:
    151         printf("interact.\n");
     143       
    152144        rc = interact(dev_handle);
    153145       
    … …  
    161153{
    162154        int input;
    163         tinput_t * in;
     155        tinput_t *in;
    164156       
    165157        in = tinput_new();
    … …  
    179171                switch(input) {
    180172                        case 'a':
    181                                 label.add_part(in, &label.data);
    182                                 break;
    183                         case 'b':
    184                                 label.add_part(in, &label.data);
     173                                label.add_part(&label, in);
    185174                                break;
    186175                        case 'd':
    187                                 label.delete_part(in, &label.data);
     176                                label.delete_part(&label, in);
    188177                                break;
    189178                        case 'e':
    190                                 label.extra_funcs(in, dev_handle, &label.data);
     179                                label.extra_funcs(&label, in, dev_handle);
    191180                                break;
    192181                        case 'f':
    … …  
    197186                                print_help();
    198187                                break;
     188                        case 'l':
     189                                set_alignment(in);
     190                                break;
    199191                        case 'n':
     192                                printf("Discarding label...\n");
    200193                                free_label();
    201                                 label.new_label(&label.data);
     194                                label.new_label(&label);
    202195                                break;
    203196                        case 'p':
    204                                 label.print_parts(&label.data);
     197                                label.print_parts(&label);
    205198                                break;
    206199                        case 'q':
    207200                                putchar('\n');
    208201                                goto end;
     202                        case 'r':
     203                                label.read_parts(&label, dev_handle);
    209204                        case 'w':
    210                                 label.write_parts(dev_handle, &label.data);
     205                                label.write_parts(&label, dev_handle);
    211206                                break;
    212207                        default:
    … …  
    228223                "\t 'd' \t\t Delete partition.\n"
    229224                "\t 'e' \t\t Extra functions (per label format).\n"
    230                 "\t 'f' \t\t Switch the format of the partition label."
     225                "\t 'f' \t\t Switch the format of the partition label.\n"
    231226                "\t 'h' \t\t Prints help. See help for more.\n"
    232227                "\t 'l' \t\t Set alignment.\n"
    233228                "\t 'n' \t\t Create new label (discarding the old one).\n"
    234229                "\t 'p' \t\t Prints label contents.\n"
     230                "\t 'q' \t\t Quit.\n"
     231                "\t 'r' \t\t Read label from disk.\n"
    235232                "\t 'w' \t\t Write label to disk.\n"
    236                 "\t 'q' \t\t Quit.\n"
    237233                );
    238234
    … …  
    244240                        "1) MBR\n"
    245241                        "2) GPT\n"
    246                 );
     242              );
    247243       
    248244        uint8_t val = get_input_uint8(in);
    … …  
    250246                case 0:
    251247                        free_label();
    252                         label.layout = LYT_NONE;
    253                         fill_label_funcs();
     248                        construct_label(LYT_NONE);
    254249                        break;
    255250                case 1:
    256251                        free_label();
    257                         label.layout = LYT_MBR;
    258                         fill_label_funcs();
     252                        construct_label(LYT_MBR);
    259253                        break;
    260254                case 2:
    261255                        free_label();
     256                        construct_label(LYT_GPT);
     257                        break;
     258        }
     259}
     260
     261void construct_label(layouts_t layout)
     262{
     263        switch(layout) {
     264                case LYT_MBR:
     265                        label.layout = LYT_MBR;
     266                        construct_mbr_label(&label);
     267                        break;
     268                case LYT_GPT:
    262269                        label.layout = LYT_GPT;
    263                         fill_label_funcs();
    264                         break;
    265         }
    266 }
    267 
    268 void fill_label_funcs(void)
    269 {
    270         switch(label.layout) {
    271                 case LYT_MBR:
    272                         construct_mbr_label();
    273                         break;
    274                 case LYT_GPT:
    275                         construct_gpt_label();
     270                        construct_gpt_label(&label);
    276271                        break;
    277272                default:
    278                         construct_none_label();
     273                        label.layout = LYT_NONE;
     274                        construct_none_label(&label);
    279275                        break;
    280276        }
    … …  
    283279void free_label(void)
    284280{
    285         /*
    286         switch(label.layout) {
    287                 case LYT_MBR:
    288                         destroy_mbr_label(&label);
    289                         break;
    290                 case LYT_GPT:
    291                         destroy_gpt_label(&label);
    292                         break;
    293                 default:
    294                         break;
    295         }
    296         */
    297        
    298         label.destroy_label(&label.data);
     281        label.destroy_label(&label);
    299282}
    300283
    301284int try_read(service_id_t dev_handle)
    302285{
    303         fill_label_funcs();
    304         printf("read_parts\n");
    305         return label.read_parts(dev_handle, &label.data);
    306 }
    307 
    308 int construct_none_label()
    309 {
    310         label.add_part      = add_none_part;
    311         label.delete_part   = delete_none_part;
    312         label.destroy_label = destroy_none_label;
    313         label.new_label     = new_none_label;
    314         label.print_parts   = print_none_parts;
    315         label.read_parts    = read_none_parts;
    316         label.write_parts   = write_none_parts;
    317         label.extra_funcs   = extra_none_funcs;
    318        
    319         return EOK;
    320 }
    321 
    322 int construct_mbr_label()
    323 {
    324         label.add_part      = add_mbr_part;
    325         label.delete_part   = delete_mbr_part;
    326         label.destroy_label = destroy_mbr_label;
    327         label.new_label     = new_mbr_label;
    328         label.print_parts   = print_mbr_parts;
    329         label.read_parts    = read_mbr_parts;
    330         label.write_parts   = write_mbr_parts;
    331         label.extra_funcs   = extra_mbr_funcs;
    332        
    333         return label.new_label(&label.data);
     286        return label.read_parts(&label, dev_handle);
    334287}
    335288
    336289int try_read_mbr(service_id_t dev_handle)
    337290{
    338         label.layout = LYT_MBR;
     291        construct_label(LYT_MBR);
    339292        return try_read(dev_handle);
    340293}
    341294
    342 int construct_gpt_label()
    343 {
    344         label.add_part    = add_gpt_part;
    345         label.delete_part = delete_gpt_part;
    346         label.new_label   = new_gpt_label;
    347         label.print_parts = print_gpt_parts;
    348         label.read_parts  = read_gpt_parts;
    349         label.write_parts = write_gpt_parts;
    350         label.extra_funcs = extra_gpt_funcs;
    351        
    352         return label.new_label(&label.data);
    353 }
    354 
    355295int try_read_gpt(service_id_t dev_handle)
    356296{
    357         label.layout = LYT_GPT;
     297        construct_label(LYT_GPT);
    358298        return try_read(dev_handle);
    359299}
    360300
    361 
    362 
    363 
    364 
    365 
    366 
    367 
    368 
    369 
    370 
    371 
    372 
    373 
    374 
    375 
    376 
    377 
    378 
    379 
    380 
    381 
    382 
    383 
    384 
    385 
     301void set_alignment(tinput_t *in)
     302{
     303        printf("Set alignment to sectors: ");
     304        label.alignment = get_input_uint32(in);
     305        printf("Alignment set to %u sectors.\n", label.alignment);
     306}
     307
     308
     309
     310
     311
     312
     313
     314
     315
     316

  • uspace/app/hdisk/hdisk.h

    rc9f61150 r6e8e4e19  
    3535#include "common.h"
    3636
    37 typedef enum {
    38         LYT_NONE,
    39         LYT_MBR,
    40         LYT_GPT,
    41 } layouts_t;
    42 
    43 typedef struct label {
    44         layouts_t layout;
    45         union label_data data;
    46         int (* add_part)     (tinput_t *,   union label_data *);
    47         int (* delete_part)  (tinput_t *,   union label_data *);
    48         int (* destroy_label)(              union label_data *);
    49         int (* new_label)    (              union label_data *);
    50         int (* print_parts)  (              union label_data *);
    51         int (* read_parts)   (service_id_t, union label_data *);
    52         int (* write_parts)  (service_id_t, union label_data *);
    53         int (* extra_funcs)  (tinput_t *, service_id_t, union label_data *);
    54 } label_t;
    55 
    5637#define init_label() \
    5738        label.layout = LYT_NONE
Note: See TracChangeset for help on using the changeset viewer.