prog: rework address allocation

1. mmap all memory always, without explicit mmap calls in the program.
This makes lots of things much easier and removes lots of code.
Makes mmap not a special syscall and allows to fuzz without mmap enabled.

2. Change address assignment algorithm.
Current algorithm allocates unmapped addresses too frequently
and allows collisions between arguments of a single syscall.
The new algorithm analyzes actual allocations in the program
and places new arguments at unused locations.

1 files changed, 5 insertions, 42 deletions

diff --git a/sys/linux/init.go b/sys/linux/init.go
index 8f8fbfcc3..a411ed97b 100644
--- a/sys/linux/init.go
+++ b/sys/linux/init.go
@@ -34,11 +34,7 @@ func initTarget(target *prog.Target) {
 		CLOCK_REALTIME:            target.ConstMap["CLOCK_REALTIME"],
 	}
 
-	target.PageSize = pageSize
-	target.DataOffset = dataOffset
-	target.MmapSyscall = arch.mmapSyscall
 	target.MakeMmap = arch.makeMmap
-	target.AnalyzeMmap = arch.analyzeMmap
 	target.SanitizeCall = arch.sanitizeCall
 	target.SpecialTypes = map[string]func(g *prog.Gen, typ prog.Type, old prog.Arg) (
 		prog.Arg, []*prog.Call){
@@ -64,9 +60,7 @@ func initTarget(target *prog.Target) {
 }
 
 const (
-	pageSize   = 4 << 10
-	dataOffset = 512 << 20
-	invalidFD  = ^uint64(0)
+	invalidFD = ^uint64(0)
 )
 
 var (
@@ -108,14 +102,14 @@ type arch struct {
 	CLOCK_REALTIME            uint64
 }
 
-// createMmapCall creates a "normal" mmap call that maps [start, start+npages) page range.
-func (arch *arch) makeMmap(start, npages uint64) *prog.Call {
+// createMmapCall creates a "normal" mmap call that maps [addr, addr+size) memory range.
+func (arch *arch) makeMmap(addr, size uint64) *prog.Call {
 	meta := arch.mmapSyscall
 	return &prog.Call{
 		Meta: meta,
 		Args: []prog.Arg{
-			prog.MakePointerArg(meta.Args[0], start, 0, npages, nil),
-			prog.MakeConstArg(meta.Args[1], npages*pageSize),
+			prog.MakeVmaPointerArg(meta.Args[0], addr, size),
+			prog.MakeConstArg(meta.Args[1], addr),
 			prog.MakeConstArg(meta.Args[2], arch.PROT_READ|arch.PROT_WRITE),
 			prog.MakeConstArg(meta.Args[3], arch.MAP_ANONYMOUS|arch.MAP_PRIVATE|arch.MAP_FIXED),
 			prog.MakeResultArg(meta.Args[4], nil, invalidFD),
@@ -125,37 +119,6 @@ func (arch *arch) makeMmap(start, npages uint64) *prog.Call {
 	}
 }
 
-func (arch *arch) analyzeMmap(c *prog.Call) (start, npages uint64, mapped bool) {
-	switch c.Meta.Name {
-	case "mmap":
-		// Filter out only very wrong arguments.
-		npages = c.Args[1].(*prog.ConstArg).Val / pageSize
-		if npages == 0 {
-			return
-		}
-		flags := c.Args[3].(*prog.ConstArg).Val
-		fd := c.Args[4].(*prog.ResultArg).Val
-		if flags&arch.MAP_ANONYMOUS == 0 && fd == invalidFD {
-			return
-		}
-		start = c.Args[0].(*prog.PointerArg).PageIndex
-		mapped = true
-		return
-	case "munmap":
-		start = c.Args[0].(*prog.PointerArg).PageIndex
-		npages = c.Args[1].(*prog.ConstArg).Val / pageSize
-		mapped = false
-		return
-	case "mremap":
-		start = c.Args[4].(*prog.PointerArg).PageIndex
-		npages = c.Args[2].(*prog.ConstArg).Val / pageSize
-		mapped = true
-		return
-	default:
-		return
-	}
-}
-
 func (arch *arch) sanitizeCall(c *prog.Call) {
 	switch c.Meta.CallName {
 	case "mmap":