Changeset 6317b33 in mainline for uspace/app


Ignore:
Timestamp:
2013-06-25T00:29:00Z (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:
52f2c89
Parents:
cb328ab (diff), 1c8bfe8 (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:

hdisk, libmbr and libgpt updates

Location:
uspace/app/hdisk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hdisk/common.h

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    3434
    3535#include <stdio.h>
     36#include <str.h>
    3637#include <errno.h>
    3738#include <str_error.h>
    … …  
    4344static int set_gpt_partition(tinput_t *, gpt_part_t *);
    4445
    45 int add_gpt_part(tinput_t * in, union label_data * data)
    46 {
    47         gpt_part_t * p = gpt_alloc_partition(data->gpt->parts);
     46
     47int construct_gpt_label(label_t *this)
     48{
     49        this->layout = LYT_GPT;
     50        this->alignment = 1;
     51       
     52        this->add_part    = add_gpt_part;
     53        this->delete_part = delete_gpt_part;
     54        this->new_label   = new_gpt_label;
     55        this->print_parts = print_gpt_parts;
     56        this->read_parts  = read_gpt_parts;
     57        this->write_parts = write_gpt_parts;
     58        this->extra_funcs = extra_gpt_funcs;
     59       
     60        return this->new_label(this);
     61}
     62
     63int add_gpt_part(label_t *this, tinput_t *in)
     64{
     65        gpt_part_t * p = gpt_get_partition(this->data.gpt);
    4866        if (p == NULL) {
    4967                return ENOMEM;
    5068        }
    51 
     69       
    5270        return set_gpt_partition(in, p);
    5371}
    5472
    55 int delete_gpt_part(tinput_t * in, union label_data * data)
    56 {
     73int delete_gpt_part(label_t *this, tinput_t *in)
     74{
     75        int rc;
    5776        size_t idx;
    58 
     77       
    5978        printf("Number of the partition to delete (counted from 0): ");
    6079        idx = get_input_size_t(in);
    61 
    62         if (gpt_remove_partition(data->gpt->parts, idx) == -1) {
     80       
     81        rc = gpt_remove_partition(this->data.gpt, idx);
     82        if (rc != EOK) {
    6383                printf("Warning: running low on memory, not resizing...\n");
    64         }
    65 
    66         return EOK;
    67 }
    68 
    69 int destroy_gpt_label(union label_data *data)
    70 {
    71         return EOK;
    72 }
    73 
    74 int new_gpt_label(union label_data *data)
    75 {
    76         data->gpt->gpt = gpt_alloc_gpt_header();
    77         data->gpt->parts = gpt_alloc_partitions();
    78         return EOK;
    79 }
    80 
    81 int print_gpt_parts(union label_data *data)
     84                return rc;
     85        }
     86       
     87        return EOK;
     88}
     89
     90int destroy_gpt_label(label_t *this)
     91{
     92        gpt_free_label(this->data.gpt);
     93        return EOK;
     94}
     95
     96int new_gpt_label(label_t *this)
     97{
     98        this->data.gpt = gpt_alloc_label();
     99        return EOK;
     100}
     101
     102int print_gpt_parts(label_t *this)
    82103{
    83104        //int rc;
    … …  
    87108        size_t i = 0;
    88109       
    89         gpt_part_foreach(data->gpt->parts, iter) {
     110        gpt_part_foreach(this->data.gpt, iter) {
     111                i++;
     112                //FIXMEE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     113                if (gpt_get_part_type(iter) == GPT_PTE_UNUSED)
     114                        continue;
     115               
     116                if (i % 20 == 0)
     117                        printf("%15s %10s %10s Type: Name:\n", "Start:", "End:", "Length:");
     118               
    90119                //printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
    91120                //              iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
    92                 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),
    93122                                gpt_get_end_lba(iter) - gpt_get_start_lba(iter), gpt_get_part_type(iter),
    94123                                gpt_get_part_name(iter));
    95                 i++;
    96         }
    97 
     124        }
     125       
    98126        //return rc;
    99127        return EOK;
    100128}
    101129
    102 int read_gpt_parts(service_id_t dev_handle, union label_data *data)
    103 {
    104         return EOK;
    105 }
    106 
    107 int write_gpt_parts(service_id_t dev_handle, union label_data * data)
    108 {
    109         int rc;
    110 
    111         rc = gpt_write_partitions(data->gpt->parts, data->gpt->gpt, dev_handle);
     130int read_gpt_parts(label_t *this, service_id_t dev_handle)
     131{
     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       
     146        return EOK;
     147}
     148
     149int write_gpt_parts(label_t *this, service_id_t dev_handle)
     150{
     151        int rc;
     152       
     153        rc = gpt_write_partitions(this->data.gpt, dev_handle);
    112154        if (rc != EOK) {
    113155                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    114156                return rc;
    115157        }
    116 
    117         rc = gpt_write_gpt_header(data->gpt->gpt, dev_handle);
    118         if (rc != EOK) {
    119                 printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    120                 return rc;
    121         }
    122 
    123         return EOK;
    124 }
    125 
    126 int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union label_data * data)
     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)
    127169{
    128170        printf("Not implemented.\n");
    … …  
    130172}
    131173
    132 static int set_gpt_partition(tinput_t * in, gpt_part_t * p)
    133 {
    134         //int rc;
    135 
     174static int set_gpt_partition(tinput_t *in, gpt_part_t *p)
     175{
     176        int rc;
     177       
    136178        uint64_t sa, ea;
    137 
     179       
    138180        printf("Set starting address (number): ");
    139181        sa = get_input_uint64(in);
    140 
     182       
    141183        printf("Set end addres (number): ");
    142184        ea = get_input_uint64(in);
    143 
     185       
    144186        if (ea <= sa) {
    145187                printf("Invalid value.\n");
    146188                return EINVAL;
    147189        }
    148 
    149 
    150         //p->start_addr = sa;
     190       
    151191        gpt_set_start_lba(p, sa);
    152         //p->length = ea - sa;
    153192        gpt_set_end_lba(p, ea);
    154 
    155         return EOK;
    156 }
    157 
     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/app/hdisk/func_gpt.h

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    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

    rcb328ab r6317b33  
    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.