| /* SPDX-License-Identifier: GPL-2.0-only */ |
| |
| package main |
| |
| import "bufio" |
| import "encoding/binary" |
| import "encoding/csv" |
| import "flag" |
| import "fmt" |
| import "io" |
| import "log" |
| import "os" |
| import "path/filepath" |
| import "sort" |
| import "strconv" |
| import "strings" |
| |
| // This program generates 32-bit PAE page tables based on a CSV input file. |
| // By default each PDPTE entry is allocated a PD page such that it's easy |
| // fault in new entries that are 2MiB aligned and size. |
| |
| var iomapFilePtr = flag.String("iomap_file", "", "CSV file detailing page table mapping") |
| var ptCFilePtr = flag.String("pt_output_c_file", "", "File to write page tables to in C code") |
| var ptBinFilePtr = flag.String("pt_output_bin_file", "", "File to write page tables to in binary") |
| var pdptCFilePtr = flag.String("pdpt_output_c_file", "", "File to write PDPT to in C code") |
| var pdptBinFilePtr = flag.String("pdpt_output_bin_file", "", "File to write PDPT to in binary") |
| var pagesBaseAddress = flag.Uint64("metadata_base_address", BASE_ADDR, "Physical base address where metadata pages allocated from") |
| |
| var generatedCodeLicense string = |
| `/* |
| * Copyright 2018 Generated Code |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ` + "``" + `AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| ` |
| |
| const ( |
| PAT_UC = 0 |
| PAT_WC = 1 |
| PAT_WT = 4 |
| PAT_WP = 5 |
| PAT_WB = 6 |
| PAT_UCMINUS = 7 |
| |
| COMMENT_CHAR = '#' |
| |
| NUM_PDPTE = 4 |
| NUM_PDE = 512 |
| NUM_PTE = 512 |
| |
| SIZE_4KiB = uint64(1 << 12) |
| MASK_4KiB = SIZE_4KiB - 1 |
| SIZE_2MiB = uint64(1 << 21) |
| MASK_2MiB = SIZE_2MiB - 1 |
| |
| // This is a fake physical address for doing fixups when loading |
| // the page tables. There's room for 4096 4KiB physical PD or PTE |
| // tables. Anything with the present bit set will be pointing to an |
| // offset based on this address. At runtime the entries will be fixed up |
| BASE_ADDR = uint64(0xaa000000) |
| |
| // Size of PD and PT structures |
| METADATA_TABLE_SIZE = 4096 |
| |
| PDPTE_PRES = uint64(1 << 0) |
| PDPTE_PWT = uint64(1 << 3) |
| PDPTE_PCD = uint64(1 << 4) |
| |
| PDE_PRES = uint64(1 << 0) |
| PDE_RW = uint64(1 << 1) |
| PDE_US = uint64(1 << 2) |
| PDE_PWT = uint64(1 << 3) |
| PDE_PCD = uint64(1 << 4) |
| PDE_A = uint64(1 << 5) |
| PDE_D = uint64(1 << 6) // only valid with PS=1 |
| PDE_PS = uint64(1 << 7) |
| PDE_G = uint64(1 << 8) // only valid with PS=1 |
| PDE_PAT = uint64(1 << 12) // only valid with PS=1 |
| PDE_XD = uint64(1 << 63) |
| |
| PTE_PRES = uint64(1 << 0) |
| PTE_RW = uint64(1 << 1) |
| PTE_US = uint64(1 << 2) |
| PTE_PWT = uint64(1 << 3) |
| PTE_PCD = uint64(1 << 4) |
| PTE_A = uint64(1 << 5) |
| PTE_D = uint64(1 << 6) |
| PTE_PAT = uint64(1 << 7) |
| PTE_G = uint64(1 << 8) |
| PTE_XD = uint64(1 << 63) |
| |
| PDPTE_IDX_SHIFT = 30 |
| PDPTE_IDX_MASK = 0x3 |
| |
| PDE_IDX_SHIFT = 21 |
| PDE_IDX_MASK = 0x1ff |
| |
| PTE_IDX_SHIFT = 12 |
| PTE_IDX_MASK = 0x1ff |
| ) |
| |
| // Different 'writers' implement this interface. |
| type pageTableEntryWriter interface { |
| WritePageEntry(data interface{}) error |
| } |
| |
| // The full page objects, page directories and page tables, implement this |
| // interface to write their entire contents out |
| type pageTableWriter interface { |
| WritePage(wr pageTableEntryWriter) error |
| } |
| |
| type binaryWriter struct { |
| wr io.Writer |
| } |
| |
| func (bw *binaryWriter) WritePageEntry(data interface{}) error { |
| return binary.Write(bw.wr, binary.LittleEndian, data) |
| } |
| |
| type cWriter struct { |
| name string |
| wr io.Writer |
| totalEntries uint |
| currentIndex uint |
| } |
| |
| func newCWriter(wr io.Writer, name string, nr_entries uint) *cWriter { |
| cw := &cWriter{wr: wr, name: name, totalEntries: nr_entries} |
| return cw |
| } |
| |
| func (cw *cWriter) WritePageEntry(data interface{}) error { |
| var entry uint64 |
| doPrint := false |
| |
| entry, ok := data.(uint64) |
| if !ok { |
| return fmt.Errorf("entry not uint64 %T", data) |
| } |
| |
| if cw.currentIndex == 0 { |
| if _, err := fmt.Fprint(cw.wr, generatedCodeLicense); err != nil { |
| return err |
| } |
| if _, err := fmt.Fprintf(cw.wr, "/* Generated by:\n util/x86/%s %s\n */\n", |
| filepath.Base(os.Args[0]), |
| strings.Join(os.Args[1:], " ")); err != nil { |
| return err |
| } |
| includes := []string{ |
| "stdint.h", |
| } |
| for _, l := range includes { |
| if _, err := fmt.Fprintf(cw.wr, "#include <%s>\n", l); err != nil { |
| return err |
| } |
| } |
| |
| if _, err := fmt.Fprintf(cw.wr, "uint64_t %s[] = {\n", cw.name); err != nil { |
| return err |
| } |
| } |
| |
| if cw.currentIndex%NUM_PTE == 0 { |
| doPrint = true |
| page_num := cw.currentIndex / NUM_PTE |
| if _, err := fmt.Fprintf(cw.wr, "\t/* Page %d */\n", page_num); err != nil { |
| return err |
| } |
| } |
| |
| // filter out 0 entries |
| if entry != 0 || doPrint { |
| _, err := fmt.Fprintf(cw.wr, "\t[%d] = %#016xULL,\n", cw.currentIndex, entry) |
| if err != nil { |
| return err |
| } |
| } |
| |
| cw.currentIndex += 1 |
| |
| if cw.currentIndex == cw.totalEntries { |
| if _, err := fmt.Fprintln(cw.wr, "};"); err != nil { |
| return err |
| } |
| } |
| |
| return nil |
| } |
| |
| // This map represents what the IA32_PAT MSR should be at runtime. The indices |
| // are what the linux kernel uses. Reserved entries are not used. |
| // 0 WB : _PAGE_CACHE_MODE_WB |
| // 1 WC : _PAGE_CACHE_MODE_WC |
| // 2 UC-: _PAGE_CACHE_MODE_UC_MINUS |
| // 3 UC : _PAGE_CACHE_MODE_UC |
| // 4 WB : Reserved |
| // 5 WP : _PAGE_CACHE_MODE_WP |
| // 6 UC-: Reserved |
| // 7 WT : _PAGE_CACHE_MODE_WT |
| // In order to use WP and WC then the IA32_PAT MSR needs to be updated |
| // as these are not the power on reset values. |
| var patMsrIndexByType = map[uint]uint{ |
| PAT_WB: 0, |
| PAT_WC: 1, |
| PAT_UCMINUS: 2, |
| PAT_UC: 3, |
| PAT_WP: 5, |
| PAT_WT: 7, |
| } |
| |
| type addressRange struct { |
| begin uint64 |
| end uint64 |
| pat uint |
| nx bool |
| } |
| |
| type addrRangeMerge func(a, b *addressRange) bool |
| |
| func (ar *addressRange) Size() uint64 { |
| return ar.end - ar.begin |
| } |
| |
| func (ar *addressRange) Base() uint64 { |
| return ar.begin |
| } |
| |
| func (ar *addressRange) Pat() uint { |
| return ar.pat |
| } |
| |
| func (ar *addressRange) Nx() bool { |
| return ar.nx |
| } |
| |
| func (ar *addressRange) String() string { |
| var nx string |
| if ar.nx { |
| nx = "NX" |
| } else { |
| nx = " " |
| } |
| return fmt.Sprintf("%016x -- %016x %s %s", ar.begin, ar.end, patTypeToString(ar.pat), nx) |
| } |
| |
| type pageTableEntry struct { |
| physAddr uint64 |
| flags uint64 |
| } |
| |
| func (pte *pageTableEntry) Encode() uint64 { |
| return pte.physAddr | pte.flags |
| } |
| |
| func ptePatFlags(base uint64, pat uint) uint64 { |
| idx, ok := patMsrIndexByType[pat] |
| patStr, _ := patTypesToString[pat] |
| |
| if !ok { |
| log.Fatalf("Invalid pat entry for page %x: %s\n", base, patStr) |
| } |
| |
| switch idx { |
| case 0: |
| return 0 |
| case 1: |
| return PTE_PWT |
| case 2: |
| return PTE_PCD |
| case 3: |
| return PTE_PCD | PTE_PWT |
| case 4: |
| return PTE_PAT |
| case 5: |
| return PTE_PAT | PTE_PWT |
| case 6: |
| return PTE_PAT | PTE_PCD |
| case 7: |
| return PTE_PAT | PTE_PCD | PTE_PWT |
| } |
| |
| log.Fatalf("Invalid PAT index %d for PTE %x %s\n", idx, base, patStr) |
| return 0 |
| } |
| |
| func (pte *pageTableEntry) SetMapping(base uint64, pat uint, nx bool) { |
| // Present and accessed |
| pte.flags |= PTE_PRES | PTE_A |
| |
| // Non write protected entries mark as writable and dirty |
| if pat != PAT_WP { |
| pte.flags |= PTE_RW |
| pte.flags |= PTE_D |
| } |
| |
| if nx { |
| pte.flags |= PTE_XD |
| } |
| |
| pte.flags |= ptePatFlags(base, pat) |
| pte.physAddr = base |
| } |
| |
| type pageTable struct { |
| ptes [NUM_PTE]pageTableEntry |
| } |
| |
| func (pt *pageTable) WritePage(wr pageTableEntryWriter) error { |
| for i := range pt.ptes { |
| pte := &pt.ptes[i] |
| err := wr.WritePageEntry(pte.Encode()) |
| if err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| type pageDirectoryEntry struct { |
| physAddr uint64 |
| flags uint64 |
| pt *pageTable |
| } |
| |
| func (pde *pageDirectoryEntry) Encode() uint64 { |
| return pde.physAddr | pde.flags |
| } |
| |
| func pdeTablePatFlags(pat uint) uint64 { |
| idx, ok := patMsrIndexByType[pat] |
| patStr, _ := patTypesToString[pat] |
| |
| if !ok || idx >= 4 { |
| log.Fatalf("Invalid pat entry for PDE page table %s\n", patStr) |
| } |
| |
| switch idx { |
| case 0: |
| return 0 |
| case 1: |
| return PDE_PWT |
| case 2: |
| return PDE_PCD |
| case 3: |
| return PDE_PCD | PDE_PWT |
| } |
| |
| log.Fatalf("Invalid PAT index %d for PDE page table %s\n", idx, patStr) |
| return 0 |
| } |
| |
| func pdeLargePatFlags(base uint64, pat uint) uint64 { |
| idx, ok := patMsrIndexByType[pat] |
| patStr, _ := patTypesToString[pat] |
| |
| if !ok { |
| log.Fatalf("Invalid pat entry for large page %x: %s\n", base, patStr) |
| } |
| |
| switch idx { |
| case 0: |
| return 0 |
| case 1: |
| return PDE_PWT |
| case 2: |
| return PDE_PCD |
| case 3: |
| return PDE_PCD | PDE_PWT |
| case 4: |
| return PDE_PAT |
| case 5: |
| return PDE_PAT | PDE_PWT |
| case 6: |
| return PDE_PAT | PDE_PCD |
| case 7: |
| return PDE_PAT | PDE_PCD | PDE_PWT |
| } |
| |
| log.Fatalf("Invalid PAT index %d for PDE %x %s\n", idx, base, patStr) |
| return 0 |
| } |
| |
| func (pde *pageDirectoryEntry) SetPageTable(pt_addr uint64, pat uint) { |
| // Set writable for whole region covered by page table. Individual |
| // ptes will have the correct writability flags |
| pde.flags |= PDE_PRES | PDE_A | PDE_RW |
| |
| pde.flags |= pdeTablePatFlags(pat) |
| |
| pde.physAddr = pt_addr |
| } |
| |
| func (pde *pageDirectoryEntry) SetMapping(base uint64, pat uint, nx bool) { |
| // Present, accessed, and large |
| pde.flags |= PDE_PRES | PDE_A | PDE_PS |
| |
| // Non write protected entries mark as writable and dirty |
| if pat != PAT_WP { |
| pde.flags |= PDE_RW |
| pde.flags |= PDE_D |
| } |
| |
| if nx { |
| pde.flags |= PDE_XD |
| } |
| |
| pde.flags |= pdeLargePatFlags(base, pat) |
| pde.physAddr = base |
| } |
| |
| type pageDirectory struct { |
| pdes [NUM_PDE]pageDirectoryEntry |
| } |
| |
| func (pd *pageDirectory) WritePage(wr pageTableEntryWriter) error { |
| for i := range pd.pdes { |
| pde := &pd.pdes[i] |
| err := wr.WritePageEntry(pde.Encode()) |
| if err != nil { |
| return nil |
| } |
| } |
| return nil |
| } |
| |
| type pageDirectoryPointerEntry struct { |
| physAddr uint64 |
| flags uint64 |
| pd *pageDirectory |
| } |
| |
| func (pdpte *pageDirectoryPointerEntry) Encode() uint64 { |
| return pdpte.physAddr | pdpte.flags |
| } |
| |
| func (pdpte *pageDirectoryPointerEntry) Init(addr uint64, pat uint) { |
| idx, ok := patMsrIndexByType[pat] |
| |
| // Only 2 bits worth of PAT indexing in PDPTE |
| if !ok || idx >= 4 { |
| patStr, _ := patTypesToString[pat] |
| log.Fatalf("Can't use type '%s' as PDPTE type.\n", patStr) |
| } |
| |
| pdpte.physAddr = addr |
| pdpte.flags = PDPTE_PRES |
| |
| switch idx { |
| case 0: |
| pdpte.flags |= 0 |
| case 1: |
| pdpte.flags |= PDPTE_PWT |
| case 2: |
| pdpte.flags |= PDPTE_PCD |
| case 3: |
| pdpte.flags |= PDPTE_PCD | PDPTE_PWT |
| default: |
| log.Fatalf("Invalid PAT index %d for PDPTE\n", idx) |
| } |
| } |
| |
| type addressSpace struct { |
| ranges []*addressRange |
| mergeFunc addrRangeMerge |
| metatdataBaseAddr uint64 |
| pdptes [NUM_PDPTE]pageDirectoryPointerEntry |
| numMetaPages uint |
| page_writers []pageTableWriter |
| } |
| |
| func (as *addressSpace) newPage(pw pageTableWriter) uint64 { |
| v := as.metatdataBaseAddr + METADATA_TABLE_SIZE*uint64(as.numMetaPages) |
| as.numMetaPages += 1 |
| as.page_writers = append(as.page_writers, pw) |
| return v |
| } |
| |
| func newAddrSpace(mergeFunc addrRangeMerge, metatdataBaseAddr uint64) *addressSpace { |
| as := &addressSpace{mergeFunc: mergeFunc, metatdataBaseAddr: metatdataBaseAddr} |
| // Fill in all PDPTEs |
| for i := range as.pdptes { |
| pdpte := &as.pdptes[i] |
| pdpte.pd = &pageDirectory{} |
| // fetch paging structures as WB |
| pdpte.Init(as.newPage(pdpte.pd), PAT_WB) |
| } |
| return as |
| } |
| |
| func (as *addressSpace) deleteEntries(indices []int) { |
| // deletions need to be processed in reverse order so as not |
| // delete the wrong entries |
| sort.Sort(sort.Reverse(sort.IntSlice(indices))) |
| for _, i := range indices { |
| as.ranges = append(as.ranges[:i], as.ranges[i+1:]...) |
| } |
| } |
| |
| func (as *addressSpace) mergeRanges() { |
| var toRemove []int |
| var prev *addressRange |
| |
| for i, cur := range as.ranges { |
| if prev == nil { |
| prev = cur |
| continue |
| } |
| |
| // merge previous with current |
| if as.mergeFunc(prev, cur) { |
| prev.end = cur.end |
| toRemove = append(toRemove, i) |
| cur = prev |
| } |
| prev = cur |
| } |
| |
| as.deleteEntries(toRemove) |
| } |
| |
| type addressRangeSlice []*addressRange |
| |
| func (p addressRangeSlice) Len() int { |
| return len(p) |
| } |
| |
| func (p addressRangeSlice) Less(i, j int) bool { |
| return !p[i].After(p[j]) |
| } |
| |
| func (p addressRangeSlice) Swap(i, j int) { |
| p[i], p[j] = p[j], p[i] |
| } |
| |
| func (as *addressSpace) insertRange(r *addressRange) { |
| as.ranges = append(as.ranges, r) |
| sort.Sort(addressRangeSlice(as.ranges)) |
| } |
| |
| // Remove complete entries or trim existing ones |
| func (as *addressSpace) trimRanges(r *addressRange) { |
| var toRemove []int |
| |
| // First remove all entries that are completely overlapped |
| for i, cur := range as.ranges { |
| if r.FullyOverlaps(cur) { |
| toRemove = append(toRemove, i) |
| continue |
| } |
| } |
| as.deleteEntries(toRemove) |
| |
| var ar *addressRange |
| |
| // Process partial overlaps |
| for _, cur := range as.ranges { |
| // Overlapping may be at beginning, middle, end. Only the |
| // middle overlap needs to create a new range since the |
| // beginning and end overlap can just adjust the current |
| // range. |
| if r.Overlaps(cur) { |
| |
| // beginning overlap |
| if r.begin <= cur.begin { |
| cur.begin = r.end |
| continue |
| } |
| |
| // end overlap |
| if r.end >= cur.end { |
| cur.end = r.begin |
| continue |
| } |
| |
| // middle overlap. create new entry from the hole |
| // punched in the current entry. There's nothing |
| // further to do after this |
| begin := r.end |
| end := cur.end |
| pat := cur.pat |
| nx := cur.nx |
| |
| // current needs new ending |
| cur.end = r.begin |
| |
| ar = newAddrRange(begin, end, pat, nx) |
| |
| break |
| } |
| } |
| |
| if ar != nil { |
| as.insertRange(ar) |
| } |
| } |
| |
| func (as *addressSpace) PrintEntries() { |
| for _, cur := range as.ranges { |
| log.Println(cur) |
| } |
| } |
| |
| func (as *addressSpace) AddRange(r *addressRange) { |
| as.trimRanges(r) |
| as.insertRange(r) |
| as.mergeRanges() |
| } |
| |
| func (as *addressSpace) insertMapping(base uint64, size uint64, pat uint, nx bool) { |
| pdpteIndex := (base >> PDPTE_IDX_SHIFT) & PDPTE_IDX_MASK |
| pdeIndex := (base >> PDE_IDX_SHIFT) & PDE_IDX_MASK |
| pteIndex := (base >> PTE_IDX_SHIFT) & PTE_IDX_MASK |
| |
| pd := as.pdptes[pdpteIndex].pd |
| pde := &pd.pdes[pdeIndex] |
| |
| if size == SIZE_2MiB { |
| pde.SetMapping(base, pat, nx) |
| return |
| } |
| |
| if pde.pt == nil { |
| pde.pt = &pageTable{} |
| // Fetch paging structures as WB |
| pde.SetPageTable(as.newPage(pde.pt), PAT_WB) |
| } |
| |
| pte := &pde.pt.ptes[pteIndex] |
| pte.SetMapping(base, pat, nx) |
| } |
| |
| func (as *addressSpace) CreatePageTables() { |
| var size uint64 |
| var base uint64 |
| |
| for _, r := range as.ranges { |
| size = r.Size() |
| base = r.Base() |
| pat := r.Pat() |
| nx := r.Nx() |
| |
| numSmallEntries := 0 |
| numBigEntries := 0 |
| |
| for size != 0 { |
| mappingSize := SIZE_4KiB |
| |
| if (base&MASK_2MiB) == 0 && size >= SIZE_2MiB { |
| mappingSize = SIZE_2MiB |
| numBigEntries += 1 |
| } else { |
| numSmallEntries += 1 |
| } |
| |
| as.insertMapping(base, mappingSize, pat, nx) |
| |
| base += mappingSize |
| size -= mappingSize |
| |
| } |
| |
| log.Printf("%s : %d big %d small\n", r, numBigEntries, numSmallEntries) |
| } |
| } |
| |
| func (as *addressSpace) PageTableSize() uint { |
| return as.numMetaPages * METADATA_TABLE_SIZE |
| } |
| |
| func (as *addressSpace) NumPages() uint { |
| return as.numMetaPages |
| } |
| |
| func (as *addressSpace) WritePageTable(ptew pageTableEntryWriter) error { |
| for _, pw := range as.page_writers { |
| err := pw.WritePage(ptew) |
| if err != nil { |
| return err |
| } |
| } |
| |
| return nil |
| } |
| |
| func (as *addressSpace) WritePageDirectoryPointerTable(ptew pageTableEntryWriter) error { |
| for i := range as.pdptes { |
| err := ptew.WritePageEntry(as.pdptes[i].Encode()) |
| if err != nil { |
| return err |
| } |
| } |
| |
| return nil |
| } |
| |
| var pat_types_from_str = map[string]uint{ |
| "UC": PAT_UC, |
| "WC": PAT_WC, |
| "WT": PAT_WT, |
| "WP": PAT_WP, |
| "WB": PAT_WB, |
| "UC-": PAT_UCMINUS, |
| } |
| |
| var patTypesToString = map[uint]string{ |
| PAT_UC: "UC", |
| PAT_WC: "WC", |
| PAT_WT: "WT", |
| PAT_WP: "WP", |
| PAT_WB: "WB", |
| PAT_UCMINUS: "UC-", |
| } |
| |
| func openCsvFile(file string) (*csv.Reader, error) { |
| f, err := os.Open(file) |
| |
| if err != nil { |
| return nil, err |
| } |
| |
| csvr := csv.NewReader(f) |
| csvr.Comment = COMMENT_CHAR |
| csvr.TrimLeadingSpace = true |
| return csvr, nil |
| } |
| |
| // After returns true if ar beings at or after other.end. |
| func (ar addressRange) After(other *addressRange) bool { |
| return ar.begin >= other.end |
| } |
| |
| func (ar addressRange) FullyOverlaps(other *addressRange) bool { |
| return ar.begin <= other.begin && ar.end >= other.end |
| } |
| |
| func (ar addressRange) Overlaps(other *addressRange) bool { |
| if other.end <= ar.begin || other.begin >= ar.end { |
| return false |
| } |
| return true |
| } |
| |
| func MergeByPat(a, b *addressRange) bool { |
| // 'b' is assumed to be following 'a' |
| if a.end != b.begin { |
| return false |
| } |
| |
| if a.pat != b.pat { |
| return false |
| } |
| |
| return true |
| } |
| |
| func MergeByNx(a, b *addressRange) bool { |
| // 'b' is assumed to be following 'a' |
| if a.end != b.begin { |
| return false |
| } |
| |
| if a.nx != b.nx { |
| return false |
| } |
| |
| return true |
| } |
| |
| func MergeByPatNx(a, b *addressRange) bool { |
| return MergeByPat(a, b) && MergeByNx(a, b) |
| } |
| |
| func hexNumber(s string) (uint64, error) { |
| return strconv.ParseUint(strings.TrimSpace(s), 0, 0) |
| } |
| |
| func patTypeToString(pat uint) string { |
| return patTypesToString[pat] |
| } |
| |
| func patTypeFromString(s string) (uint, error) { |
| s1 := strings.TrimSpace(s) |
| v, ok := pat_types_from_str[s1] |
| |
| if !ok { |
| return 0, fmt.Errorf("No PAT type '%s'", s1) |
| } |
| |
| return v, nil |
| } |
| |
| func removeComment(field, comment string) string { |
| str_slice := strings.Split(field, comment) |
| return strings.TrimSpace(str_slice[0]) |
| } |
| |
| func newAddrRange(begin, end uint64, pat uint, nx bool) *addressRange { |
| return &addressRange{begin: begin, end: end, pat: pat, nx: nx} |
| } |
| |
| func readRecords(csvr *csv.Reader, as *addressSpace) { |
| i := 0 |
| for true { |
| fields, err := csvr.Read() |
| i++ |
| |
| if err == io.EOF { |
| break |
| } |
| |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| if len(fields) < 3 { |
| log.Fatal("Need at least 3 fields: begin, end, PAT\n") |
| } |
| |
| begin, err := hexNumber(fields[0]) |
| |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| end, err := hexNumber(fields[1]) |
| |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| if begin&MASK_4KiB != 0 { |
| log.Fatalf("begin %x must be at least 4KiB aligned\n", begin) |
| } |
| |
| if end&MASK_4KiB != 0 { |
| log.Fatalf("end %x must be at least 4KiB aligned\n", end) |
| } |
| if begin >= end { |
| log.Fatalf("%x must be < %x at record %d\n", begin, end, i) |
| } |
| |
| pat, err := patTypeFromString(fields[2]) |
| |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| var nx bool = false |
| |
| if len(fields) > 3 && len(removeComment(fields[3], string(COMMENT_CHAR))) > 0 { |
| nx = true |
| } |
| |
| as.AddRange(newAddrRange(begin, end, pat, nx)) |
| } |
| } |
| |
| func main() { |
| log.SetFlags(0) |
| flag.Parse() |
| var ptWriters []pageTableEntryWriter |
| var pdptWriters []pageTableEntryWriter |
| |
| if *iomapFilePtr == "" { |
| log.Fatal("No iomap_file provided.\n") |
| } |
| |
| csvr, err := openCsvFile(*iomapFilePtr) |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| as := newAddrSpace(MergeByPatNx, *pagesBaseAddress) |
| readRecords(csvr, as) |
| |
| log.Println("Merged address space:") |
| as.CreatePageTables() |
| log.Println() |
| log.Printf("Total Pages of page tables: %d\n", as.NumPages()) |
| log.Println() |
| log.Printf("Pages linked using base address of %#x.\n", *pagesBaseAddress) |
| |
| if *ptCFilePtr != "" { |
| f, err := os.Create(*ptCFilePtr) |
| if err != nil { |
| log.Fatal(err) |
| } |
| defer f.Close() |
| bwr := bufio.NewWriter(f) |
| defer bwr.Flush() |
| cw := newCWriter(bwr, "page_tables", as.NumPages()*NUM_PTE) |
| ptWriters = append(ptWriters, cw) |
| } |
| |
| if *ptBinFilePtr != "" { |
| f, err := os.Create(*ptBinFilePtr) |
| if err != nil { |
| log.Fatal(err) |
| } |
| defer f.Close() |
| bwr := bufio.NewWriter(f) |
| defer bwr.Flush() |
| bw := &binaryWriter{wr: bwr} |
| ptWriters = append(ptWriters, bw) |
| } |
| |
| if *pdptCFilePtr != "" { |
| f, err := os.Create(*pdptCFilePtr) |
| if err != nil { |
| log.Fatal(err) |
| } |
| defer f.Close() |
| bwr := bufio.NewWriter(f) |
| defer bwr.Flush() |
| cw := newCWriter(bwr, "pdptes", NUM_PDPTE) |
| pdptWriters = append(pdptWriters, cw) |
| } |
| |
| if *pdptBinFilePtr != "" { |
| f, err := os.Create(*pdptBinFilePtr) |
| if err != nil { |
| log.Fatal(err) |
| } |
| defer f.Close() |
| bwr := bufio.NewWriter(f) |
| defer bwr.Flush() |
| bw := &binaryWriter{wr: bwr} |
| pdptWriters = append(pdptWriters, bw) |
| } |
| |
| // Write out page tables |
| for _, w := range ptWriters { |
| err = as.WritePageTable(w) |
| if err != nil { |
| log.Fatal(err) |
| } |
| } |
| |
| // Write out pdptes |
| for _, w := range pdptWriters { |
| err = as.WritePageDirectoryPointerTable(w) |
| if err != nil { |
| log.Fatal(err) |
| } |
| } |
| } |