| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package gpt |
| |
| import ( |
| "bytes" |
| "encoding/binary" |
| "os" |
| "reflect" |
| "testing" |
| "unicode/utf16" |
| |
| "thinfs/mbr" |
| ) |
| |
| func TestReadHeader(t *testing.T) { |
| h, err := ReadHeader(bytes.NewReader(exampleDisk()[512:])) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| assertStructEqual(t, h, exampleGPT().Primary.Header) |
| } |
| |
| func TestReadPartitionEntry(t *testing.T) { |
| p, err := ReadPartitionEntry(bytes.NewReader(exampleDisk()[1024:])) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| assertStructEqual(t, p, exampleGPT().Primary.Partitions[0]) |
| } |
| |
| func TestReadGPT(t *testing.T) { |
| g, err := ReadGPT(bytes.NewReader(exampleDisk()), 512, exampleDiskSize) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| eg := exampleGPT() |
| |
| assertStructEqual(t, g.MBR, eg.MBR) |
| assertStructEqual(t, g.Primary.Header, eg.Primary.Header) |
| for i, pe := range eg.Primary.Partitions { |
| assertStructEqual(t, g.Primary.Partitions[i], pe) |
| } |
| assertStructEqual(t, g.Backup.Header, eg.Backup.Header) |
| for i, pe := range eg.Backup.Partitions { |
| assertStructEqual(t, g.Backup.Partitions[i], pe) |
| } |
| } |
| |
| func TestGPTWrite(t *testing.T) { |
| var b bytes.Buffer |
| eg := exampleGPT() |
| eg.Update(512, 4096, 0, exampleDiskSize) |
| if _, err := eg.WriteTo(&b); err != nil { |
| t.Fatal(err) |
| } |
| |
| got := b.Bytes() |
| want := exampleDisk() |
| |
| if !bytes.Equal(got, want) { |
| t.Errorf("got\n%x\nwant\n%x", got, want) |
| } |
| } |
| |
| func TestUpdate(t *testing.T) { |
| var ( |
| logicalBlockSize uint64 = 512 |
| physicalBlockSize uint64 = 4096 |
| optimalTransferLengthGranularity uint64 |
| ) |
| eg := exampleGPT() |
| |
| g := GPT{ |
| Primary: PartitionTable{ |
| Header: Header{ |
| DiskGUID: eg.Primary.DiskGUID, |
| }, |
| Partitions: []PartitionEntry{ |
| eg.Primary.Partitions[0], |
| }, |
| }, |
| } |
| |
| |
| alignment := physicalBlockSize / logicalBlockSize |
| |
| if err := g.Update(logicalBlockSize, physicalBlockSize, optimalTransferLengthGranularity, exampleDiskSize); err != nil { |
| t.Fatal(err) |
| } |
| |
| t.Run("Primary", func(t *testing.T) { |
| assertStructEqual(t, g.Primary.Header, eg.Primary.Header) |
| }) |
| t.Run("Backup", func(t *testing.T) { |
| assertStructEqual(t, g.Backup.Header, eg.Backup.Header) |
| }) |
| |
| t.Run("Optimal Transfer Alignment", func(t *testing.T) { |
| optimalTransferLengthGranularity = 8192 |
| alignment = optimalTransferLengthGranularity / logicalBlockSize |
| |
| if err := g.Update(logicalBlockSize, physicalBlockSize, optimalTransferLengthGranularity, exampleDiskSize); err != nil { |
| t.Fatal(err) |
| } |
| |
| if got := g.Primary.Partitions[0].StartingLBA % alignment; got != 0 { |
| t.Errorf("StartingLBA alignment: got %d, want %d", got, 0) |
| } |
| }) |
| |
| t.Run("Larger disk size", func(t *testing.T) { |
| diskSize := exampleDiskSize + logicalBlockSize |
| |
| if err := g.Update(logicalBlockSize, physicalBlockSize, optimalTransferLengthGranularity, diskSize); err != nil { |
| t.Fatal(err) |
| } |
| |
| if got := g.Primary.AlternateLBA; got != eg.Primary.AlternateLBA+1 { |
| t.Errorf("AlternateLBA: got %d, want %d", got, eg.Primary.AlternateLBA+1) |
| } |
| }) |
| } |
| |
| func TestValidateGPT(t *testing.T) { |
| cases := []struct { |
| name string |
| gpt GPT |
| mut func(g *GPT) |
| err ErrInvalidGPT |
| }{ |
| { |
| name: "valid gpt", |
| mut: func(g *GPT) {}, |
| err: nil, |
| }, |
| { |
| name: "bad primary signature", |
| mut: func(g *GPT) { g.Primary.Signature = Signature{} }, |
| err: ErrInvalidGPT{ErrInvalidSignature}, |
| }, |
| { |
| name: "bad backup signature", |
| mut: func(g *GPT) { g.Backup.Signature = Signature{} }, |
| err: ErrInvalidGPT{ErrInvalidSignature}, |
| }, |
| { |
| name: "bad primary MyLBA", |
| mut: func(g *GPT) { g.Primary.MyLBA = 0 }, |
| err: ErrInvalidGPT{ErrInvalidAddress}, |
| }, |
| { |
| name: "bad backup AlternateLBA", |
| mut: func(g *GPT) { g.Backup.AlternateLBA = 0 }, |
| err: ErrInvalidGPT{ErrInvalidAddress}, |
| }, |
| { |
| name: "bad primary AlternateLBA", |
| mut: func(g *GPT) { g.Primary.AlternateLBA = 0 }, |
| err: ErrInvalidGPT{ErrInvalidAddress}, |
| }, |
| { |
| name: "bad backup MyLBA", |
| mut: func(g *GPT) { g.Backup.MyLBA = 0 }, |
| err: ErrInvalidGPT{ErrInvalidAddress}, |
| }, |
| { |
| name: "bad primary CRC", |
| mut: func(g *GPT) { g.Primary.HeaderCRC32 = 0 }, |
| err: ErrInvalidGPT{ErrHeaderCRC}, |
| }, |
| { |
| name: "bad backup CRC", |
| mut: func(g *GPT) { g.Backup.HeaderCRC32 = 0 }, |
| err: ErrInvalidGPT{ErrHeaderCRC}, |
| }, |
| { |
| name: "bad primary partition array crc", |
| mut: func(g *GPT) { g.Primary.PartitionEntryArrayCRC32 = 0 }, |
| err: ErrInvalidGPT{ErrHeaderCRC}, |
| }, |
| { |
| name: "bad backup partition array crc", |
| mut: func(g *GPT) { g.Backup.PartitionEntryArrayCRC32 = 0 }, |
| err: ErrInvalidGPT{ErrHeaderCRC}, |
| }, |
| } |
| |
| for _, c := range cases { |
| t.Run(c.name, func(t *testing.T) { |
| var g = exampleGPT() |
| c.mut(&g) |
| e := g.Validate() |
| if e == nil { |
| if c.err == nil { |
| return |
| } |
| t.Errorf("got %v, want %v", e, c.err) |
| } |
| |
| err := e.(ErrInvalidGPT) |
| for i, want := range c.err { |
| if i > len(err)-1 { |
| t.Errorf("missing expected error %s", want) |
| continue |
| } |
| if got := err[i]; got != want { |
| t.Errorf("got %#v, want %#v", got, want) |
| } |
| } |
| }) |
| } |
| } |
| |
| func TestGUID(t *testing.T) { |
| want := "C12A7328-F81F-11D2-BA4B-00A0C93EC93B" |
| g, err := NewGUID(want) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if got := g.String(); got != want { |
| t.Errorf("got %q, want %q", got, want) |
| } |
| |
| s := "2967380E-134C-4CBB-B6DA-17E7CE1CA45D" |
| b := []byte{ |
| 0x0e, 0x38, 0x67, 0x29, |
| 0x4c, 0x13, |
| 0xbb, 0x4c, |
| 0xb6, 0xda, 0x17, 0xe7, 0xce, 0x1c, 0xa4, 0x5d} |
| |
| g, err = NewGUID(s) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var buf bytes.Buffer |
| binary.Write(&buf, binary.LittleEndian, &g) |
| if !bytes.Equal(b, buf.Bytes()) { |
| t.Errorf("got %x, want %x", buf.Bytes(), b) |
| } |
| |
| if g.String() != s { |
| t.Errorf("got %x, want %x", g.String(), s) |
| } |
| |
| if GUIDBIOS != GUIDS["bios"] { |
| t.Errorf("got %x, want %x", GUIDS["bios"], GUIDBIOS) |
| } |
| |
| if want := "bios"; GUIDBIOS.Name() != want { |
| t.Errorf("got %q, want %q", GUIDBIOS.Name(), want) |
| } |
| |
| // this guid is a non-named guid, assert that it is returned by name() as a |
| // fallback. |
| s = "99999999-9999-9999-9999-999999999999" |
| g, err = NewGUID(s) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if g.Name() != s { |
| t.Errorf("got %x, want %x", g.Name(), s) |
| } |
| } |
| |
| func TestGetPhysicalBlockSize(t *testing.T) { |
| t.Skip("GetPhysicalBlockSize requires elevated priviliges") |
| f, err := os.Open("/dev/sda") |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer f.Close() |
| sz, err := GetPhysicalBlockSize(f) |
| if err != nil { |
| t.Fatal(err) |
| } |
| t.Log(sz) |
| } |
| |
| func TestPartitionName(t *testing.T) { |
| name := "abcdefghijklmnopqrstuvwxyzabcdef" |
| want := [72]byte{ |
| 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, |
| 0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6a, 0x00, 0x6b, 0x00, 0x6c, 0x00, |
| 0x6d, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x71, 0x00, 0x72, 0x00, |
| 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x76, 0x00, 0x77, 0x00, 0x78, 0x00, |
| 0x79, 0x00, 0x7a, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, |
| 0x65, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| } |
| pn := NewPartitionName(name) |
| if pn != want { |
| t.Errorf("got %#v, want %#v", pn, want) |
| } |
| if got := pn.String(); got != name { |
| t.Errorf("got %q, want %q", got, name) |
| } |
| } |
| |
| // returns the binary byte size of an arbitrary object. this is different from |
| // unsafe.Sizeof, which returns the C-ABI size of an object, which includes |
| // padding rules that don't apply to binary writes. |
| func byteSizeOf(v interface{}) int { |
| var b bytes.Buffer |
| binary.Write(&b, binary.LittleEndian, v) |
| return b.Len() |
| } |
| |
| func TestSizes(t *testing.T) { |
| if want := byteSizeOf(PartitionEntry{}); PartitionEntrySize != want { |
| t.Errorf("PartitionEntrySize: got %d, want %d", PartitionEntrySize, want) |
| } |
| if want := byteSizeOf(Header{}); HeaderSize != want { |
| t.Errorf("HeaderSize: got %d, want %d", HeaderSize, want) |
| } |
| } |
| |
| func TestNextAlignedLBA(t *testing.T) { |
| examples := []struct { |
| in [4]uint64 |
| want uint64 |
| }{ |
| {[4]uint64{0, 512, 0, 0}, 0}, |
| {[4]uint64{1, 512, 0, 0}, 1}, |
| {[4]uint64{2, 512, 0, 0}, 2}, |
| {[4]uint64{1, 512, 4096, 0}, 8}, |
| {[4]uint64{1, 512, 4096, 65536}, 128}, |
| {[4]uint64{50, 512, 4096, 0}, 56}, |
| {[4]uint64{150, 512, 4096, 65536}, 256}, |
| } |
| for _, ex := range examples { |
| if got, want := NextAlignedLBA(ex.in[0], ex.in[1], ex.in[2], ex.in[3]), ex.want; got != want { |
| t.Errorf("got %d, want %d, for %v", got, want, ex.in) |
| } |
| } |
| } |
| |
| func TestAlignedRange(t *testing.T) { |
| examples := []struct { |
| in [5]uint64 |
| want [2]uint64 |
| }{ |
| {[5]uint64{0, 1024, 512, 0, 0}, [2]uint64{0, 2}}, |
| {[5]uint64{1, 1024, 512, 0, 0}, [2]uint64{1, 3}}, |
| {[5]uint64{2, 1024, 512, 0, 0}, [2]uint64{2, 4}}, |
| {[5]uint64{1, 1024, 512, 4096, 0}, [2]uint64{8, 15}}, |
| {[5]uint64{1, 1024, 512, 4096, 65536}, [2]uint64{128, 255}}, |
| {[5]uint64{50, 1024, 512, 4096, 0}, [2]uint64{56, 63}}, |
| {[5]uint64{150, 1024, 512, 4096, 65536}, [2]uint64{256, 383}}, |
| {[5]uint64{256, 65536 - 512, 512, 4096, 65536}, [2]uint64{256, 383}}, |
| {[5]uint64{256, 65536, 512, 4096, 65536}, [2]uint64{256, 511}}, |
| } |
| for _, ex := range examples { |
| gs, ge := AlignedRange(ex.in[0], ex.in[1], ex.in[2], ex.in[3], ex.in[4]) |
| ws, we := ex.want[0], ex.want[1] |
| if gs != ws || ge != we { |
| t.Errorf("got [%d,%d], want [%d,%d], for %v", gs, ge, ws, we, ex.in) |
| } |
| } |
| } |
| |
| // TODO(raggi): produce a set of examples to test instead of just one |
| |
| const exampleDiskSize = 51200 |
| |
| func exampleDisk() []byte { |
| // The contents of this method are effectively a reformatted hexdump of a real |
| // image created with a disk image tool. |
| |
| var d = make([]byte, exampleDiskSize) |
| |
| copy(d[0x000001b0:], []byte{ |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, |
| 0xff, 0xff, 0xee, 0xfe, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, |
| }) |
| |
| copy(d[0x000001f0:], []byte{ |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa, |
| 0x45, 0x46, 0x49, 0x20, 0x50, 0x41, 0x52, 0x54, 0x00, 0x00, 0x01, 0x00, 0x5c, 0x00, 0x00, 0x00, |
| 0x71, 0x65, 0x6f, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x46, 0x91, 0x1a, 0x61, 0xba, 0xaf, 0x4c, |
| 0x99, 0x91, 0xb7, 0xd6, 0xe4, 0x91, 0xed, 0x50, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x5a, 0x95, 0x81, 0x63, 0x00, 0x00, 0x00, 0x00, |
| }) |
| |
| copy(d[0x00000400:], []byte{ |
| 0x00, 0x53, 0x46, 0x48, 0x00, 0x00, 0xaa, 0x11, 0xaa, 0x11, 0x00, 0x30, 0x65, 0x43, 0xec, 0xac, |
| 0xd4, 0xf2, 0x0c, 0x08, 0x62, 0xe0, 0xcf, 0x42, 0xbf, 0x54, 0xbf, 0x34, 0x00, 0xb4, 0x89, 0x4d, |
| 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x69, 0x00, 0x73, 0x00, 0x6b, 0x00, |
| 0x20, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, |
| }) |
| |
| copy(d[0x00008600:], []byte{ |
| 0x00, 0x53, 0x46, 0x48, 0x00, 0x00, 0xaa, 0x11, 0xaa, 0x11, 0x00, 0x30, 0x65, 0x43, 0xec, 0xac, |
| 0xd4, 0xf2, 0x0c, 0x08, 0x62, 0xe0, 0xcf, 0x42, 0xbf, 0x54, 0xbf, 0x34, 0x00, 0xb4, 0x89, 0x4d, |
| 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x69, 0x00, 0x73, 0x00, 0x6b, 0x00, |
| 0x20, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, |
| }) |
| |
| copy(d[0x0000c600:], []byte{ |
| 0x45, 0x46, 0x49, 0x20, 0x50, 0x41, 0x52, 0x54, 0x00, 0x00, 0x01, 0x00, 0x5c, 0x00, 0x00, 0x00, |
| 0x3d, 0x70, 0x6d, 0x59, 0x00, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x46, 0x91, 0x1a, 0x61, 0xba, 0xaf, 0x4c, |
| 0x99, 0x91, 0xb7, 0xd6, 0xe4, 0x91, 0xed, 0x50, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x5a, 0x95, 0x81, 0x63, 0x00, 0x00, 0x00, 0x00, |
| }) |
| |
| return d |
| } |
| |
| func exampleGPT() GPT { |
| bname := [72]byte{} |
| name16 := utf16.Encode([]rune("disk image")) |
| for i, r := range name16 { |
| binary.LittleEndian.PutUint16(bname[i*2:], r) |
| } |
| pe := PartitionEntry{ |
| PartitionTypeGUID: GUIDAppleHFSPlus, |
| UniquePartitionGUID: mustNewGUID("080CF2D4-E062-42CF-BF54-BF3400B4894D"), |
| StartingLBA: uint64(40), |
| EndingLBA: uint64(63), |
| Attributes: uint64(0), |
| PartitionName: bname, |
| } |
| g := GPT{ |
| MBR: mbr.MBR{ |
| Signature: mbr.GPTSignature, |
| PartitionRecord: [4]mbr.PartitionRecord{ |
| mbr.PartitionRecord{ |
| StartingCHS: [3]byte{254, 255, 255}, |
| OSType: mbr.GPTProtective, |
| EndingCHS: [3]byte{254, 255, 255}, |
| StartingLBA: 1, |
| SizeInLBA: 99, |
| }, |
| }, |
| }, |
| Primary: PartitionTable{ |
| Header: Header{ |
| Signature: EFISignature, |
| Revision: EFIRevision, |
| HeaderSize: HeaderSize, |
| HeaderCRC32: 3849282929, |
| MyLBA: 1, |
| AlternateLBA: uint64(exampleDiskSize/512 - 1), |
| FirstUsableLBA: 34, |
| LastUsableLBA: uint64((exampleDiskSize - 512 - 16384 - 512) / 512), |
| DiskGUID: mustNewGUID("1A91465A-BA61-4CAF-9991-B7D6E491ED50"), |
| PartitionEntryLBA: uint64(2), |
| NumberOfPartitionEntries: uint32(128), |
| SizeOfPartitionEntry: uint32(128), |
| PartitionEntryArrayCRC32: uint32(1669436762), |
| }, |
| Partitions: make([]PartitionEntry, 128), |
| }, |
| Backup: PartitionTable{ |
| Header: Header{ |
| Signature: EFISignature, |
| Revision: EFIRevision, |
| HeaderSize: HeaderSize, |
| HeaderCRC32: 1500344381, |
| MyLBA: uint64(exampleDiskSize/512 - 1), |
| AlternateLBA: 1, |
| FirstUsableLBA: 34, |
| LastUsableLBA: uint64((exampleDiskSize - 512 - 16384 - 512) / 512), |
| DiskGUID: mustNewGUID("1A91465A-BA61-4CAF-9991-B7D6E491ED50"), |
| PartitionEntryLBA: uint64(67), |
| NumberOfPartitionEntries: uint32(128), |
| SizeOfPartitionEntry: uint32(128), |
| PartitionEntryArrayCRC32: uint32(1669436762), |
| }, |
| Partitions: make([]PartitionEntry, 128), |
| }, |
| } |
| g.Primary.Partitions[0] = pe |
| g.Backup.Partitions[0] = pe |
| |
| return g |
| } |
| |
| // assertStructEqual compares flat structure a to flat structure b, printing an |
| // error message containing the field name for any field that does not match. |
| func assertStructEqual(t *testing.T, got, want interface{}) { |
| gotv := reflect.ValueOf(got) |
| wantv := reflect.ValueOf(want) |
| |
| if gotv.Kind() != reflect.Struct || wantv.Kind() != reflect.Struct { |
| t.Fatalf("not a struct: %v or %v", gotv.Kind(), wantv.Kind()) |
| } |
| |
| for i := 0; i < wantv.NumField(); i++ { |
| if wantv.Type() != gotv.Type() { |
| t.Fatalf("mismatched types: %#v and %#v", gotv, wantv) |
| } |
| |
| if !wantv.Field(i).CanInterface() { |
| t.Logf("cannot compare field: %v", wantv.Type().Field(i)) |
| continue |
| } |
| goti := gotv.Field(i).Interface() |
| wanti := wantv.Field(i).Interface() |
| |
| if goti != wanti { |
| t.Errorf("%s:\n got %v,\n want %v", wantv.Type().Field(i).Name, goti, wanti) |
| } |
| } |
| } |
