github.com/mvdan/u-root-coreutils@v0.0.0-20230122170626-c2eef2898555/cmds/exp/cbmem/gen/gen.go (about)

     1  // Copyright 2021 the u-root Authors. All rights reserved
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package main
     6  
     7  import (
     8  	"bytes"
     9  	"flag"
    10  	"fmt"
    11  	"log"
    12  	"os"
    13  	"syscall"
    14  )
    15  
    16  var apu2 = flag.Bool("apu2", false, "Use hardcoded values for an APU2 -- very iffy")
    17  
    18  // This is a known set of offsets for the APU2.
    19  // It is very unlikely to be widely applicable but it
    20  // is useful for a bootstrap. Not recommended for wide use.
    21  func genAPU2(n string) ([]byte, error) {
    22  	// mmap(NULL, 4096, PROT_READ, MAP_SHARED, 3, 0) = 0x7fa13d64f000
    23  	// mmap(NULL, 1320, PROT_READ, MAP_SHARED, 3, 0) = 0x7fa13d64e000
    24  	// mmap(NULL, 4096, PROT_READ, MAP_SHARED, 3, 0x77fae000) = 0x7fa13d64d000
    25  	// mmap(NULL, 392, PROT_READ, MAP_SHARED, 3, 0x77fae000) = 0x7fa13d64c000
    26  	// mmap(NULL, 8, PROT_READ, MAP_SHARED, 3, 0x77fdf000) = 0x7fa13d64f000
    27  	// mmap(NULL, 65, PROT_READ, MAP_SHARED, 3, 0x77fdf000) = 0x7fa13d64f000
    28  	f, err := os.Open("/dev/mem")
    29  	if err != nil {
    30  		return nil, err
    31  	}
    32  	out := bytes.NewBuffer([]byte("package main\nvar apu2 = []seg {\n"))
    33  	for _, m := range []struct {
    34  		offset int64
    35  		size   int64
    36  	}{
    37  		{size: 4096, offset: 0},
    38  		{size: 1320, offset: 0},
    39  		{size: 4096, offset: 0x77fae000},
    40  		{size: 392, offset: 0x77fae000},
    41  		{size: 8, offset: 0x77fdf000},
    42  		{size: 65, offset: 0x77fdf000},
    43  	} {
    44  		b, err := syscall.Mmap(int(f.Fd()), m.offset, int(m.size), syscall.PROT_READ, syscall.MAP_SHARED)
    45  		if err != nil {
    46  			return nil, fmt.Errorf("mmap %d bytes at %#x: %v", m.size, m.offset, err)
    47  		}
    48  		fmt.Fprintf(out, "{off: %#x, dat:[]byte{\n", m.offset)
    49  		for i := 0; i < len(b); i += 8 {
    50  			fmt.Fprintf(out, "\t/*%#08x*/\t", m.offset+int64(i))
    51  			for j := 0; j < 8 && i+j < len(b); j++ {
    52  				c := b[i+j]
    53  				fmt.Fprintf(out, "%#02x/*%q*/, ", c, c)
    54  			}
    55  			fmt.Fprintf(out, "\n")
    56  		}
    57  		fmt.Fprintf(out, "\t},},\n")
    58  
    59  	}
    60  	fmt.Fprintf(out, "}\n")
    61  	return out.Bytes(), nil
    62  }
    63  
    64  func main() {
    65  	flag.Parse()
    66  	if len(flag.Args()) != 1 {
    67  		log.Fatal("Usage: gen [-apu2] outputfile.go")
    68  	}
    69  	if *apu2 {
    70  		s, err := genAPU2("apu2")
    71  		if err != nil {
    72  			log.Fatal(err)
    73  		}
    74  		if err := os.WriteFile("apu2.go", []byte(s), 0o644); err != nil {
    75  			log.Fatal(err)
    76  		}
    77  		os.Exit(0)
    78  	}
    79  
    80  	// This will only be useful when we have some working dump code.
    81  	// a := flag.Args()
    82  	// if len(a) != 1 {
    83  	// 	log.Fatal("usage: %s platform-name")
    84  	// }
    85  	// h, err := os.Hostname()
    86  	// if err != nil {
    87  	// 	log.Fatal(err)
    88  	// }
    89  	// gen(h)
    90  	log.Fatal("not yet")
    91  }