func New(hostowner string) *FS {
	owner := hostowner
	if owner == "" {
		owner = "adm"
	}
	fs := &FS{
		path:      uint64(5),
		pathmap:   make(map[uint64]bool),
		fidnew:    make(chan (chan *Fid)),
		hostowner: owner,
	}
	fs.group = newGroup(fs, owner)
	root := newNode(fs, "/", owner, "adm", 0755|plan9.DMDIR, 0, nil)
	adm := newNode(fs, "adm", "adm", "adm", 0770|plan9.DMDIR, 1, nil)
	group := newNode(fs, "group", "adm", "adm", 0660, 2, fs.group)
	ctl := newNode(fs, "ctl", "adm", "adm", 0220, 3, newCtl(fs))
	root.children["adm"] = adm
	adm.children["group"] = group
	adm.children["ctl"] = ctl
	root.parent = root
	adm.parent = root
	group.parent = adm
	ctl.parent = adm
	if owner != "adm" {
		n := newNode(fs, owner, owner, owner, 0750|plan9.DMDIR, 4, nil)
		n.parent = root
		root.children[owner] = n
	}
	fs.root = root
	go fs.newFid(fs.fidnew)
	return fs
}
New starts a 9P2000 file server keeping all files in memory. The
filesystem is entirely maintained in memory, no external storage is
used. File data is allocated in 128 * 1024 byte blocks.

The root of the filesystem is owned by the user who invoked ramfs and
is created with Read, Write and Execute permissions for the owner and
Read and Execute permissions for everyone else (0755). FS create the
necessary directories and files in /adm/ctl, /adm/group and
/<hostowner>.
package ramfs
import (
	"net"
	"path"
	"strings"
	"sync"
	"9fans.net/go/plan9"
)
const maxPath = uint64(1<<64 - 1)
const (
	MSIZE = 128*1024 + plan9.IOHDRSZ  
	IOUNIT    = 128 * 1024
	BLOCKSIZE = 2 * 1024 * 1024  
	OREAD   = plan9.OREAD    
	OWRITE  = plan9.OWRITE   
	ORDWR   = plan9.ORDWR    
	OEXEC   = plan9.OEXEC    
	OTRUNC  = plan9.OTRUNC   
	ORCLOSE = plan9.ORCLOSE  
	OEXCL   = plan9.OEXCL    
	OAPPEND = plan9.OAPPEND  
	QTDIR    = plan9.QTDIR     
	QTAPPEND = plan9.QTAPPEND  
	QTEXCL   = plan9.QTEXCL    
	QTAUTH   = plan9.QTAUTH    
	QTTMP    = plan9.QTTMP     
	QTFILE   = plan9.QTFILE    
	DMDIR    = plan9.DMDIR     
	DMAPPEND = plan9.DMAPPEND  
	DMEXCL   = plan9.DMEXCL    
	DMAUTH   = plan9.DMAUTH    
	DMTMP    = plan9.DMTMP     
	DMREAD   = plan9.DMREAD    
	DMWRITE  = plan9.DMWRITE   
	DMEXEC   = plan9.DMEXEC    
)
type LogFunc func(format string, v ...interface{})
type FS struct {
	mu        sync.Mutex
	path      uint64
	pathmap   map[uint64]bool
	fidnew    chan (chan *Fid)
	root      *node
	group     *group
	hostowner string
	chatty    bool  
	Log       LogFunc
}