Tools for working with or creating MBR-formatted disk images

[reynir]

It would be nice to develop one or more tools to:

• Inspect a MBR header's content. For example printing out what partions it contains, their size and type etc.
• Retrieve data contents of partitions for example to stdout or a file
  • Write data contents from a file or stdin to a partition
• Resizing partitions in a disk image
• Create a MBR formatted disk image with contents from files passed as command line arguments. Padding and empty sections may optionally be passed.

[PizieDust]

Hello @reynir
It will be my pleasure to try this issue. Please can I be assigned here?

[reynir]

@PizieDust what would you like to work on? I suggest working on one of the two first as they are not as difficult as the latter two. It may be helpful to look at the wikipedia article. We implement the "modern standard MBR". https://en.wikipedia.org/wiki/Master_boot_record

To create a new binary executable you can use dune init exec --libs mbr mbr_inspect bin/. This will create a directory bin/ with files mbr_inspect.ml and dune. You write the code in mbr_inspect.ml.

[PizieDust]

Hi @reynir , I apologize for the delay on this issue. This is my first time working with functional programming.
For this task, will it be better to create a new .ml file in the lib directory or is it okay to modify the code in mbr.ml to achieve the task.

[PizieDust]

@PizieDust what would you like to work on? I suggest working on one of the two first as they are not as difficult as the latter two. It may be helpful to look at the wikipedia article. We implement the "modern standard MBR". https://en.wikipedia.org/wiki/Master_boot_record

To create a new binary executable you can use dune init exec --libs mbr mbr_inspect bin/. This will create a directory bin/ with files mbr_inspect.ml and dune. You write the code in mbr_inspect.ml.

Okay thank you. This is very helpful.

[PizieDust]

@reynir
So, for the first task, my understanding is that we need a function or a module that can receive as input a MBR header and read it's contents which are:

  bootstrap_code : string;
  original_physical_drive : int;
  seconds : int;
  minutes : int;
  hours : int;
  disk_signature : int32;
  partitions : Partition.t list;

or for the modern mbr standard which contains the fields:

  bootstrap_code1 : uint8_t; [@len 218]
  _zeroes_1 : uint8_t; [@len 2]
  original_physical_drive : uint8_t;
  seconds : uint8_t;
  minutes : uint8_t;
  hours : uint8_t;
  bootstrap_code2 : uint8_t; [@len 216]
  disk_signature : uint32_t;
  _zeroes_2 : uint8_t; [@len 2]
  partitions : uint8_t; [@len 64]
  signature1 : uint8_t; (* 0x55 *)
  signature2 : uint8_t; (* 0xaa *)

and for each of the partitions (max 4), we also iterate over them and read the fields which are:

    active : bool;
    first_absolute_sector_chs : Geometry.t;
    ty : int;
    last_absolute_sector_chs : Geometry.t;
    first_absolute_sector_lba : int32;
    sectors : int32;

In the file lib/mbr.ml, it is my understanding the function unmarshalfunction converts the MBR header from a cstruct to an ocaml record.

So my question is, in the implementation of mbr_inspect.ml, can we use this unmarshal function to first parse the mbr header into an ocaml record and then access the fields of the record and print them?

we also have an unmarshal function in the partition module.

I'm trying to figure out the ocaml syntax on how to achieve this. hope I am in the right direction?

[PizieDust]

For the second task, here is a basic implementation I have (pardon the wrong syntax)

let print_partition partition =
     Printf.printf "Active: partition.Partition.active;
     Printf.printf "Type: partition.Partition.ty;
...

[reynir]

Yes, you're on the right track. Use the unmarshal to parse the MBR header from a cstruct. A Cstruct.t is a kind of buffer. You can use Cstruct.of_string to convert a string to a Cstruct.t if you're reading strings.

The difference between the type t and type mbr is the latter is very close to the disk layout and includes attributes used for code generation using the "ppx" mechanism. The generated code helps parse the raw modern standard MBR format. You don't have to worry much about that for now. The former is an OCaml record as you note. It is a higher level representation. The zeroes are left out, and the bootstrap code is concatenated. In other words we hide away some unimportant details of the underlying representation.

[PizieDust]

@reynir I'm trying to create a partition with the code (which will be saved in a file) and then use this partition to test the code for this task, but I keep having errors with creating the partition. Here is the code I am using:

    let disk_length_bytes = Int32.(mul (mul 16l 1024l) 1024l) in
    let disk_length_sectors = Int32.(div disk_length_bytes 512l) in
    let start_sector = 2048l in
    let length_sectors = Int32.sub disk_length_sectors start_sector in
    let partition1 = Mbr.Partition.make ~active:true ~ty:6 start_sector length_sectors in
    let mbr = Mbr.make [ partition1 ] in
    match mbr with
    | Ok -> print_endline "MBR created"
    | Error msg -> Printf.printf "MBR failed %s\n" msg

running dune build gives the error:

11| let mbr = Mbr.make [ partition1 ] in (* partitions is underlined *)
Error: This expression has type (Mbr.Partition.t, string) result but an expression was expected of type Mbr.Partition.t

Please what could I be doing wrongly?

[reynir]

Edit: I forgot to explain the error. The error is due to Mbr.Partition.make returning a "result" type. You need to match in the same way as you do for the result of Mbr.make.

I created a test archive (in a .tar.gz due to github limitations): test.img.tar.gz

I used the following commands:

$ fallocate -l 2M test.img # Allocate a 2 MB file, which is 4 sectors
$ parted --align none test.img mklabel msdos # Write MBR
$ parted --align none test.img mkpart primary 1s 1s # Add a one-sector partition
$ parted --align none test.img mkpart primary 2s 3s # Add a two-sector partition (remaining space)

The argument --align none tells parted to not try to align things in a way required by old operating systems (and/or disks).

[PizieDust]

Oh I see. Thank you. I just downloaded the archive. It'll come in really handy. thanks much