Changeset 271e24a in mainline for uspace/app/hdisk

Timestamp:

2013-03-24T00:12:25Z (13 years ago)

Author:

Dominik Taborsky (AT DOT) <brembyseznamcz>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

30440ed

Parents:

ec50ac4a

Message:

hdisk - testing libmbr

Location:

uspace/app/hdisk

Files:

• Makefile (modified) (2 diffs)
• func_gpt.c (modified) (1 diff)
• func_gpt.h (modified) (1 diff)
• func_mbr.c (modified) (3 diffs)
• func_mbr.h (modified) (1 diff)
• hdisk.c (modified) (9 diffs)

uspace/app/hdisk/Makefile

@@ -32 +32 @@
         $(LIBBLOCK_PREFIX)/libblock.a $(LIBCLUI_PREFIX)/libclui.a \
         $(LIBC_PREFIX)/libc.a
-EXTRA_CFLAGS = -I$(LIBMBR_PREFIX) -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX)
+EXTRA_CFLAGS = -I$(LIBMBR_PREFIX) -I$(LIBGPT_PREFIX) -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX)
 BINARY = hdisk
 
@@ -38 +38 @@
         hdisk.c \
         func_mbr.c \
-        func_gpt.c 
+        func_gpt.c \
+        input.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/hdisk/func_gpt.c

@@ -33 +33 @@
  */
 
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+
 #include "func_gpt.h"
+
+int add_gpt_part(tinput_t * in, union table_data * data)
+{
+        int rc = EOK;
+        
+        return rc;
+}
+
+int delete_gpt_part(tinput_t * in, union table_data * data)
+{
+        int rc = EOK;
+        
+        return rc;
+}
+
+int print_gpt_parts(union table_data * data)
+{
+        int rc = EOK;
+        
+        return rc;
+}
+
+int write_gpt_parts(service_id_t dev_handle, union table_data * data)
+{
+        int rc = EOK;
+        
+        return rc;
+}
+

uspace/app/hdisk/func_gpt.h

@@ -34 +34 @@
 
 #ifndef __FUNC_GPT_H__
-#def    __FUNC_GPT_H__
+#define __FUNC_GPT_H__
 
-int add_gpt_part(tinput_t * in, gpt_parts_t * parts);
-int delete_gpt_part(tinput_t * in, gpt_parts_t * parts);
-extern void print_gpt_partitions(gpt_parts_t * parts);
-extern void write_gpt_parts(gpt_parts_t * parts, gpt_t * mbr, service_id_t dev_handle);
+#include <loc.h>
+#include <tinput.h>
+#include <libgpt.h>
+
+#include "common.h"
+
+extern int add_gpt_part(tinput_t * in, union table_data * data);
+extern int delete_gpt_part(tinput_t * in, union table_data * data);
+extern int print_gpt_parts(union table_data * data);
+extern int write_gpt_parts(service_id_t dev_handle, union table_data * data);
 
 #endif

uspace/app/hdisk/func_mbr.c

@@ -33 +33 @@
  */
 
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+
 #include "func_mbr.h"
+#include "input.h"
 
-int add_mbr_part(tinput_t * in, mbr_parts_t * parts)
+static int set_mbr_partition(tinput_t * in, mbr_part_t * p);
+
+
+int add_mbr_part(tinput_t * in, union table_data * data)
 {
-        part_t * part = mbr_alloc_partition();
-
-        printf("Primary (p) or logical (l): ");
-        int input = getchar();
-
-        switch(input) {
-                case 'p':
-                        mbr_set_flag(parts, ST_LOGIC, false);
-                case 'l':
-                        mbr_set_flag(parts, ST_LOGIC, false);
-                default:
-                        printf("Invalid type. Cancelled.");
-                        return EINVAL;
-        }
+        int rc;
+        
+        mbr_part_t * part = mbr_alloc_partition();
 
         set_mbr_partition(in, part);
 
-        mbr_add_partition(parts, part);
+        rc = mbr_add_partition(data->mbr.parts, part);
+        if (rc != EOK) {
+                printf("Error adding partition.\n");
+        }
+        
+        
+        return rc;
 }
 
-int delete_mbr_part(tinput_t * in, part_t * parts)
+int delete_mbr_part(tinput_t * in, union table_data * data)
 {
-        char * str;
         int rc;
-        part_t * temp = NULL;
-        part_t * p = parts;
-        uint32_t i, input = 0;
-        char * endptr;
+        size_t idx;
 
         printf("Number of the partition to delete (counted from 0): ");
+        idx = get_input_size_t(in);
 
-        if((rc = get_input(in, &str)) != EOK)
-                return rc;
-
-        //convert from string to base 10 number
-        if(str_uint32_t(str, &endptr, 10, true, &input) != EOK) {
-                printf("Invalid value. Canceled.\n");
-                return EINVAL;
-        }
-
-        free(str);
-
-        rc = mbr_remove_partition(parts, input);
+        rc = mbr_remove_partition(data->mbr.parts, idx);
         if(rc != EOK) {
                 printf("Error: something.\n");
@@ -88 +77 @@
 
 /** Print current partition scheme */
-void print_mbr_partitions(mbr_parts_t * parts)
+int print_mbr_parts(union table_data * data)
 {
         int num = 0;
@@ -95 +84 @@
         printf("\t\tBootable:\tStart:\tEnd:\tLength:\tType:\n");
 
-        mbr_part_foreach(parts, it) {
+        mbr_part_foreach(data->mbr.parts, it) {
                 if (it->type == PT_UNUSED)
                         continue;
 
-                printf("\t P%d:\t", i);
-                if (p->bootable)
+                printf("\t P%d:\t", num);
+                if (mbr_get_flag(it, ST_BOOT))
                         printf("*");
                 else
                         printf(" ");
 
-                printf("\t\t%llu\t%llu\t%llu\t%d\n", p->start_addr, p->start_addr + p->length, p->length, p->type);
+                printf("\t\t%u\t%u\t%u\t%d\n", it->start_addr, it->start_addr + it->length, it->length, it->type);
 
                 ++num;
-        }*/
+        }
 
         printf("%d partitions found.\n", num);
+        
+        return EOK;
 }
 
-void write_mbr_parts(mbr_parts_t * parts, mbr_t * mbr, service_id_t dev_handle)
+int write_mbr_parts(service_id_t dev_handle, union table_data * data)
 {
-        int rc = mbr_write_partitions(parts, mbr, dev_handle);
+        int rc = mbr_write_partitions(data->mbr.parts, data->mbr.mbr, dev_handle);
         if (rc != EOK) {
                 printf("Error occured during writing. (ERR: %d)\n", rc);
         }
+        
+        return rc;
 }
+
+
+
+static int set_mbr_partition(tinput_t * in, mbr_part_t * p)
+{
+        int c;
+        uint8_t type;
+        
+        printf("Primary (p) or logical (l): ");
+        c = getchar();
+
+        switch(c) {
+                case 'p':
+                        mbr_set_flag(p, ST_LOGIC, false);
+                case 'l':
+                        mbr_set_flag(p, ST_LOGIC, true);
+                default:
+                        printf("Invalid type. Cancelled.");
+                        return EINVAL;
+        }
+        
+        printf("Set type (0-255): ");
+        type = get_input_uint8(in);
+
+        ///TODO: there can only be one bootable partition; let's do it just like fdisk
+        printf("Bootable? (y/n): ");
+        c = getchar();
+        if (c != 'y' && c != 'Y' && c != 'n' && c != 'N') {
+                printf("Invalid value. Cancelled.");
+                return EINVAL;
+        }
+        
+        mbr_set_flag(p, ST_BOOT, (c == 'y' || c == 'Y') ? true : false);
+
+
+        uint32_t sa, ea;
+
+        printf("Set starting address (number): ");
+        sa = get_input_uint32(in);
+
+        printf("Set end addres (number): ");
+        ea = get_input_uint32(in);
+        
+        if(ea < sa) {
+                printf("Invalid value. Canceled.\n");
+                return EINVAL;
+        }
+
+        p->type = type;
+        p->start_addr = sa;
+        p->length = ea - sa;
+
+        return EOK;
+}
+
+
+
+
+
+

uspace/app/hdisk/func_mbr.h

@@ -34 +34 @@
 
 #ifndef __FUNC_MBR_H__
-#def    __FUNC_MBR_H__
+#define __FUNC_MBR_H__
 
-int add_mbr_part(tinput_t * in, mbr_parts_t * parts);
-int delete_mbr_part(tinput_t * in, mbr_parts_t * parts);
-extern void print_mbr_partitions(mbr_parts_t * parts);
-extern void write_mbr_parts(mbr_parts_t * parts, mbr_t * mbr, service_id_t dev_handle);
+#include <loc.h>
+#include <tinput.h>
+#include <libmbr.h>
+
+#include "common.h"
+
+extern int add_mbr_part(tinput_t * in, union table_data * data);
+extern int delete_mbr_part(tinput_t * in, union table_data * data);
+extern int print_mbr_parts(union table_data * data);
+extern int write_mbr_parts(service_id_t dev_handle, union table_data * data);
 
 #endif

uspace/app/hdisk/hdisk.c

@@ -38 +38 @@
 #include <stdio.h>
 #include <ipc/services.h>
-#include <libblock.h>
+#include <block.h>
 #include <errno.h>
 #include <stdlib.h>
@@ -44 +44 @@
 #include <str.h>
 #include <libmbr.h>
+#include <libgpt.h>
 #include <tinput.h>
 
+#include "hdisk.h"
 #include "func_mbr.h"
 #include "func_gpt.h"
 
-enum TABLES {
-        TBL_MBR,
-        TBL_GPT;
-};
-
-static TABLES table;
-
-int get_input(tinput_t * in, char ** str);
-void interact(mbr_parts_t * partitions, mbr_t * mbr, service_id_t dev_handle);
+int interact(service_id_t dev_handle);
 void print_help(void);
-
-
-int set_primary(tinput_t * in, mbr_parts_t * parts);
-int add_logical(tinput_t * in, mbr_parts_t * parts);
-int set_mbr_partition(tinput_t * in, mbr_parts_t * p);
+void fill_table_funcs(void);
+void free_table(void);
+
+static table_t table;
 
 int main(int argc, char ** argv)
@@ -80 +73 @@
                 return -1;
         }
-
-        mbr_parts_t * parts = NULL;
-        gpt_header_t * g_hdr = NULL;
-        gpt_parts_t * g_parts = NULL;
-
+        
+        init_table();
+        
         mbr_t * mbr = mbr_read_mbr(dev_handle);
         if(mbr == NULL) {
                 printf("Failed to read the Master Boot Record.\n"       \
-                           "Either memory allocation or disk access failed.\n");
+                           "Either memory allocation or disk access failed. Exiting.\n");
                 return -1;
         }
 
         if(mbr_is_mbr(mbr)) {
-                table = TBL_MBR;
-                parts = mbr_read_partitions(mbr);
+                table.layout = LYT_MBR;
+                set_table_mbr(mbr);
+                mbr_partitions_t * parts = mbr_read_partitions(mbr);
                 if(parts == NULL) {
                         printf("Failed to read and parse partitions.\n" \
-                                   "Creating new partition table.")
-                }
+                                   "Creating new partition table.");
+                        parts = mbr_alloc_partitions();
+                }
+                set_table_mbr_parts(parts);
+                fill_table_funcs();
         } else {
-                table = TBL_GPT;
-                //g_hdr = gpt_read_header();
-                //g_parts = gpt_read_partitions();
-        }
-
-
-        rc = interact(partitions, mbr, dev_handle);
-
-        if(gpt) {
-                gpt_free_partitions();
-                gpt_free_header();
-        } else {
-                mbr_free_partitions(partitions);
+                table.layout = LYT_GPT;
                 mbr_free_mbr(mbr);
-        }
+                gpt_t * gpt = gpt_read_gpt_header(dev_handle);
+                if(gpt == NULL) {
+                        printf("Failed to read and parse GPT header. Exiting.\n");
+                        return -1;
+                }
+                set_table_gpt(gpt);
+                gpt_partitions_t * parts = gpt_read_partitions(gpt);
+                if(parts == NULL) {
+                        printf("Failed to read and parse partitions.\n" \
+                                   "Creating new partition table.");
+                        //parts = gpt_alloc_partitions();
+                }
+                set_table_gpt_parts(parts);
+                fill_table_funcs();
+        }
+
+        rc = interact(dev_handle);
+
+        free_table();
 
         return rc;
 }
 
+/*
 int get_input(tinput_t * in, char ** str)
 {
@@ -158 +160 @@
         return EOK;
 }
-
-//int get_input(tinput_t * in, char ** str)
-//{
-//      int rc;
-//      printf("help1\n");
-//      rc = tinput_read(in, str);
-//      if (rc == ENOENT) {
-//              /* User requested exit */
-//              return EINTR;
-//      }
-//      printf("help2\n");
-//      fflush(stdout);
-//      if (rc != EOK) {
-//              printf("Failed reading input. Cancelling...\n");
-//              return rc;
-//      }
-//      printf("help3\n");
-//      fflush(stdout);
-//      /* Check for empty input. */
-//      if (str_cmp(*str, "") == 0) {
-//              printf("Canceled.\n");
-//              return EINVAL;
-//      }
-//      printf("help4\n");
-//      fflush(stdout);
-//
-//      return EOK;
-//}
+*/
+
 
 /** Interact with user */
-int interact_mbr(mbr_parts_t * partitions, mbr_t * mbr, service_id_t dev_handle)
-{
-        char * str;
+int interact(service_id_t dev_handle)
+{
         //int rc;
+        int input;
         tinput_t * in;
 
@@ -197 +173 @@
         if (in == NULL) {
                 printf("Failed initing input. Free some memory.\n");
-                return;
-        }
-
-        tinput_set_prompt(in, " ");
+                return ENOMEM;
+        }
 
         printf("Welcome to hdisk.\nType 'h' for help.\n");
 
         //printf("# ");
-        //int input = getchar();
+        //input = getchar();
         //printf("%c\n", input);
 
         while (1) {
 
-                /*printf("# ");
-                int input = getchar();
-                printf("%c\n", input);
-                */
-
-                rc = tinput_read(in, &str);
-                if (rc == ENOENT) {
-                        // User requested exit
-                        putchar('\n');
-                        return rc;
-                }
-                if (rc != EOK) {
-                        printf("Failed reading input. Exiting...\n");
-                        return rc;
-                }
-                // Check for empty input.
-                if (str_cmp(str, "") == 0)
-                        continue;
-
-                switch(*str) {
+                //printf("# ");
+                input = getchar();
+                //printf("%c\n", input);
+                
+
+                //rc = tinput_read(in, &str);
+                //if (rc == ENOENT) {
+                        //// User requested exit
+                        //putchar('\n');
+                        //return rc;
+                //}
+                //if (rc != EOK) {
+                        //printf("Failed reading input. Exiting...\n");
+                        //return rc;
+                //}
+                //// Check for empty input.
+                //if (str_cmp(str, "") == 0)
+                        //continue;
+
+                switch(input) {
                         case 'a':
-                                add_part(in, partitions);
+                                table.add_part(in, &table.data);
                                 break;
                         case 'd':
-                                delete_part(in, partitions);
+                                table.delete_part(in, &table.data);
                                 break;
                         case 'h':
@@ -240 +214 @@
                                 break;
                         case 'p':
-                                print_MBR(partitions);
+                                table.print_parts(&table.data);
                                 break;
                         case 'q':
                                 putchar('\n');
-                                return;
+                                goto end;
                         case 'w':
-                                write_parts(partitions, mbr, dev_handle);
+                                table.write_parts(dev_handle, &table.data);
                                 break;
                         default:
@@ -258 +232 @@
         }
 
+end:
         tinput_destroy(in);
 
-        return;
+        return EOK;
 }
 
@@ -269 +244 @@
                 "\t 'd' \t\t Delete partition.\n"
                 "\t 'h' \t\t Prints help. See help for more.\n" \
-                "\t 'p' \t\t Prints the MBR contents.\n" \
+                "\t 'p' \t\t Prints the table contents.\n" \
+                "\t 'w' \t\t Write table to disk.\n" \
                 "\t 'q' \t\t Quit.\n" \
                 );
@@ -275 +251 @@
 }
 
-//other functions
-//FIXME: need error checking after input
-int set_primary(tinput_t * in, part_t * parts)
-{
-        char * str;
-        int rc;
-        uint32_t input = 5;
-        part_t * p = parts;
-        //char c_input[2];
-        char * endptr;
-
-//      while (input > 3) {
-//              printf("Number of the primary partition to set (0-3): ");
-//              str_uint64(fgets(c_input, 1, stdin), &endptr, 10, true, &input);
-//              printf("%llu\n", input);
-//      }
-
-        if ((rc = get_input(in, &str)) != EOK)
-                return rc;
-
-        if (str_uint32_t(str, &endptr, 10, true, &input) != EOK || input > 3) {
-                printf("Invalid value. Canceled.\n");
-                return EINVAL;
-        }
-
-        free(str);
-
-        for (; input > 0; --input) {
-                p = p->next;
-        }
-
-        set_partition(in, p);
-
-        return EOK;
-}
-
-int add_logical(tinput_t * in, part_t * parts)
-{
-        int i;
-        part_t * p = parts;
-        part_t * ext = NULL;
-
-        //checking primary partitions for extended partition
-        for (i = 0; i < N_PRIMARY; ++i) {
-                if (p->type == PT_EXTENDED) {
-                        ext = p;
-                        break;
-                }
-                p = p->next;
-        }
-
-        if (ext == NULL) {
-                printf("Error: no extended partition.\n");
-                return EINVAL;
-        }
-
-        while (p->next != NULL) {
-                p = p->next;
-        }
-
-        p->next = malloc(sizeof(part_t));
-        if (p->next == NULL) {
-                printf("Error: not enough memory.\n");
-                return ENOMEM;
-        }
-
-        p->next->ebr = malloc(sizeof(br_block_t));
-        if (p->next->ebr == NULL) {
-                printf("Error: not enough memory.\n");
-                return ENOMEM;
-        }
-
-        set_partition(in, p->next);
-
-        return EOK;
-}
-
-int set_mbr_partition(tinput_t * in, part_t * p)
-{
-        char * str;
-        int rc;
-        uint8_t type;
-        char * endptr;
-
-//      while (type > 255) {
-//              printf("Set type (0-255): ");
-//              str_uint64(fgets(c_type, 3, stdin), &endptr, 10, true, &type);
-//      }
-
-        if ((rc = get_input(in, &str)) != EOK)
-                return rc;
-
-        if (str_uint8_t(str, &endptr, 10, true, &type) != EOK) {
-                printf("Invalid value. Canceled.\n");
-                return EINVAL;
-        }
-
-        free(str);
-
-        ///TODO: there can only be one bootable partition; let's do it just like fdisk
-        printf("Bootable? (y/n): ");
-        int c = getchar();
-        printf("%c\n", c);
-        if (c != 'y' && c != 'Y' && c != 'n' && c != 'N') {
-                printf("Invalid value. Cancelled.");
-                return EINVAL;
-        }
-
-        uint32_t sa, ea;
-
-        printf("Set starting address (number): ");
-        //str_uint64(fgets(c_sa, 21, stdin), &endptr, 10, true, &sa);
-
-        if ((rc = get_input(in, &str)) != EOK)
-                return rc;
-
-        if(str_uint32_t(str, &endptr, 10, true, &sa) != EOK) {
-                printf("Invalid value. Canceled.\n");
-                return EINVAL;
-        }
-
-        free(str);
-
-        printf("Set end addres (number): ");
-        //str_uint64(fgets(c_len, 21, stdin), &endptr, 10, true, &len);
-
-        if ((rc = get_input(in, &str)) != EOK)
-                return rc;
-
-        if(str_uint32_t(str, &endptr, 10, true, &ea) != EOK || ea < sa) {
-                printf("Invalid value. Canceled.\n");
-                return EINVAL;
-        }
-
-        free(str);
-
-        p->type = type;
-        p->bootable = (c == 'y' || c == 'Y') ? true : false;
-        p->start_addr = sa;
-        p->length = ea - sa;
-
-        return EOK;
-}
-
-
+void fill_table_funcs(void)
+{
+        switch(table.layout) {
+                case LYT_MBR:
+                        table.add_part = add_mbr_part;
+                        table.delete_part = delete_mbr_part;
+                        table.print_parts = print_mbr_parts;
+                        table.write_parts = write_mbr_parts;
+                        break;
+                case LYT_GPT:
+                        table.add_part = add_gpt_part;
+                        table.delete_part = delete_gpt_part;
+                        table.print_parts = print_gpt_parts;
+                        table.write_parts = write_gpt_parts;
+                        break;
+                default:
+                        break;
+        }
+}
+
+void free_table(void)
+{
+        switch(table.layout) {
+                case LYT_MBR:
+                        mbr_free_partitions(table.data.mbr.parts);
+                        mbr_free_mbr(table.data.mbr.mbr);
+                        break;
+                case LYT_GPT:
+                        gpt_free_partitions(table.data.gpt.parts);
+                        gpt_free_gpt(table.data.gpt.gpt);
+                        break;
+                default:
+                        break;
+        }
+}
+