Esempio n. 1
0
func newMap(f *os.File, opts ...Option) (*mmap, error) {
	m := &mmap{
		flags: -1,
		prot:  -1,
		len:   -1,
	}

	for _, opt := range opts {
		opt(m)
	}

	if m.flags == -1 || m.prot == -1 {
		return nil, fmt.Errorf("must pass options to set the flag or prot values")
	}

	if f == nil && !m.anon {
		return nil, fmt.Errorf("f arg cannot be nil, anon was %v", m.anon)
	}

	var fd uintptr

	if m.anon {
		fd = ^uintptr(0)
		m.flags = m.flags | syscall.MAP_ANON
		if m.len <= 0 {
			return nil, fmt.Errorf("must use Length() if using Anon() option")
		}
	} else {
		fd = f.Fd()

		s, err := f.Stat()
		if err != nil {
			return nil, err
		}

		if s.Size() == 0 {
			return nil, fmt.Errorf("cannot mmap 0 length file")
		}

		if m.len == -1 {
			m.len = int(s.Size())
		}
	}

	var err error
	if m.anon {
		m.data, err = syscall.Mmap(-1, 0, m.len, m.prot, m.flags)
	} else {
		m.data, err = syscall.Mmap(int(fd), m.offset, m.len, m.prot, m.flags)
	}

	if err != nil {
		return nil, fmt.Errorf("problem with mmap system call: %q", err)
	}

	return m, nil
}
Esempio n. 2
0
// Open returns a pisearch object that references the two files
// name.4.idx and name.4.bin, or error if the files could not
// be opened and memory mapped.
func Open(name string) (pisearch *Pisearch, err error) {
	file, err := os.Open(name + ".4.bin")
	if err != nil {
		log.Println("open of .4.bin failed")
		return nil, err
	}
	fi, err := file.Stat()
	if err != nil {
		log.Println("stat failed")
		file.Close()
		return nil, err
	}

	numdigits := fi.Size() * 2

	idxfile, err := os.Open(name + ".4.idx")
	if err != nil {
		log.Println("open of .4.idx failed")
		file.Close()
		return nil, err
	}
	idxfi, err := idxfile.Stat()
	if err != nil {
		log.Println("stat of idx failed")
		idxfile.Close()
		file.Close()
		return nil, err
	}

	filemap, err := syscall.Mmap(int(file.Fd()), 0, int(fi.Size()), syscall.PROT_READ, syscall.MAP_PRIVATE)
	if err != nil {
		log.Println("mmap of file failed")
		file.Close()
		idxfile.Close()
		return nil, err
	}

	idxmap, err := syscall.Mmap(int(idxfile.Fd()), 0, int(idxfi.Size()), syscall.PROT_READ, syscall.MAP_PRIVATE)
	if err != nil {
		log.Println("mmap of idx file failed")
		syscall.Munmap(filemap)
		file.Close()
		idxfile.Close()
		return nil, err
	}

	return &Pisearch{file, filemap, int(numdigits), idxfile, idxmap}, nil
}
Esempio n. 3
0
// seqMmapRead does n sequential reads of records of size rsize using mmap and copy.
func seqMmapRead(fname string, rsize int, n int) (int, error) {
	f, err := os.Open(fname)
	if err != nil {
		return 0, err
	}
	defer f.Close()
	fi, err := f.Stat()
	if err != nil {
		return 0, err
	}
	fsize := int(fi.Size())
	data, err := syscall.Mmap(int(f.Fd()), 0, fsize, syscall.PROT_READ, syscall.MAP_FILE|syscall.MAP_SHARED)
	// syscall.Madvise(data, syscall.MADV_SEQUENTIAL)
	defer syscall.Munmap(data)
	buf := make([]byte, rsize)
	if n <= 0 || n > fsize/rsize {
		n = fsize / rsize
	}
	var i int
	for i = 0; i < n; i++ {
		offset := i * rsize
		copy(buf, data[offset:offset+len(buf)])
	}
	return i, nil
}
Esempio n. 4
0
func newInputPreloader(filePath string) (*inputPreloader, error) {
	if filePath == "/dev/null" {
		return nil, nil
	}
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	info, err := file.Stat()
	if err != nil {
		return nil, err
	}
	preloader := &inputPreloader{
		file:     file,
		fileSize: info.Size(),
	}
	mapping, err := syscall.Mmap(
		int(preloader.file.Fd()),
		0,
		int(preloader.fileSize),
		syscall.PROT_READ,
		syscall.MAP_SHARED,
	)
	if err == nil {
		pageSize := os.Getpagesize()
		preloader.mapping = mapping
		for i := 0; i < int(preloader.fileSize); i += pageSize {
			preloader.checksum += preloader.mapping[i]
		}
	} else {
		// mmap failed, so just read all the file.
		io.Copy(ioutil.Discard, preloader.file)
	}
	return preloader, nil
}
Esempio n. 5
0
func (this *ByteProfile) FindValue(doc_id int64) ([]byte, error) {
	if doc_id >= this.Len || doc_id < 1 {

		return nil, errors.New("docid is wrong")
	}

	if this.ProfileList[doc_id].InMomory == true {
		return this.ProfileList[doc_id].Data, nil
	}

	f, _ := os.Open(fmt.Sprintf("./index/%v_pfl.dat", this.Name))
	defer f.Close()
	fi, err := f.Stat()
	if err != nil {
		fmt.Printf("ERR:%v", err)
	}
	MmapBytes, err := syscall.Mmap(int(f.Fd()), 0, int(fi.Size()), syscall.PROT_READ, syscall.MAP_PRIVATE)
	if err != nil {
		fmt.Printf("MAPPING ERROR  %v \n", err)
		return nil, err
	}
	defer syscall.Munmap(MmapBytes)

	StartPos := int(this.ProfileList[doc_id].Start)
	EndPos := this.ProfileList[doc_id].DataLen + StartPos
	this.ProfileList[doc_id].Data = make([]byte, this.ProfileList[doc_id].DataLen)
	copy(this.ProfileList[doc_id].Data, MmapBytes[StartPos:EndPos])
	//fmt.Printf("Cost Time : %v \n",functime("MmapBytes"))

	this.ProfileList[doc_id].InMomory = true
	//fmt.Printf("list : %v\n", string(this.ProfileList[doc_id].Data))
	return this.ProfileList[doc_id].Data, nil

}
Esempio n. 6
0
File: cgroup.go Progetto: vosst/csi
func NewCGroup(pid int) (*Cgroup, error) {
	fn := filepath.Join(Dir(pid), "cgroup")

	f, err := os.Open(fn)

	if err != nil {
		return nil, errors.New(fmt.Sprintf("Failed to read %s [%s]", fn, err))
	}

	defer f.Close()

	stat, err := f.Stat()

	if err != nil {
		return nil, errors.New(fmt.Sprintf("Failed to stat %s [%s]", fn, err))
	}

	b, err := syscall.Mmap(int(f.Fd()), 0, int(stat.Size()), syscall.PROT_READ, syscall.MAP_PRIVATE)

	if err != nil {
		return nil, errors.New(fmt.Sprintf("Failed to mmap %s [%s]", fn, err))
	}

	defer syscall.Munmap(b)

	return NewCgroupFromReader(bytes.NewReader(b)), nil
}
Esempio n. 7
0
func helperMmap() {
	f, err := os.Create("child")
	if err != nil {
		log.Fatalf("Create: %v", err)
	}
	defer f.Close()

	data, err := syscall.Mmap(int(f.Fd()), 0, mmapSize, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
	if err != nil {
		log.Fatalf("Mmap: %v", err)
	}

	for i, b := range mmapWrites {
		data[i] = b
	}

	if err := syscallx.Msync(data, syscall.MS_SYNC); err != nil {
		log.Fatalf("Msync: %v", err)
	}

	if err := syscall.Munmap(data); err != nil {
		log.Fatalf("Munmap: %v", err)
	}

	if err := f.Sync(); err != nil {
		log.Fatalf("Fsync = %v", err)
	}

	err = f.Close()
	if err != nil {
		log.Fatalf("Close: %v", err)
	}
}
Esempio n. 8
0
func (t *FsyncErrorTest) Msync() {
	var err error

	// On OS X, msync does not cause SyncFile.
	if isDarwin {
		return
	}

	// Open the file.
	t.f1, err = os.OpenFile(path.Join(t.Dir, "foo"), os.O_RDWR, 0)
	AssertEq(nil, err)

	// mmap the file.
	data, err := syscall.Mmap(
		int(t.f1.Fd()), 0, 4,
		syscall.PROT_READ|syscall.PROT_WRITE,
		syscall.MAP_SHARED)

	AssertEq(nil, err)
	defer syscall.Munmap(data)

	// msync the mapping.
	err = msync(data)
	ExpectThat(err, Error(HasSubstr("no such file")))

	// Unmap.
	err = syscall.Munmap(data)
	AssertEq(nil, err)
}
Esempio n. 9
0
File: gpio.go Progetto: hagna/rpi
func initGPIO(memfd int) {
	buf, err := syscall.Mmap(memfd, BCM2835_GPIO_BASE, BCM2835_BLOCK_SIZE, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
	if err != nil {
		log.Fatalf("rpi: unable to mmap GPIO page: %v", err)
	}
	gpfsel = []*uint32{
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPFSEL0])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPFSEL1])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPFSEL2])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPFSEL3])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPFSEL4])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPFSEL5])),
	}
	gpset = []*uint32{
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPSET0])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPSET1])),
	}
	gpclr = []*uint32{
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPCLR0])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPCLR1])),
	}
	gplev = []*uint32{
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPLEV0])),
		(*uint32)(unsafe.Pointer(&buf[BCM2835_GPLEV1])),
	}
}
Esempio n. 10
0
// Open takes a string path to a MaxMind DB file and returns a Reader
// structure or an error. The database file is opened using a memory map. Use
// the Close method on the Reader object to return the resources to the
// system.
func Open(file string) (*Reader, error) {
	mapFile, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	stats, err := mapFile.Stat()
	if err != nil {
		return nil, err
	}

	fileSize := int(stats.Size())
	mmap, err := syscall.Mmap(int(mapFile.Fd()), 0, fileSize, syscall.PROT_READ, syscall.MAP_SHARED)
	if err != nil {
		return nil, err
	}

	reader, err := FromBytes(mmap)
	if err != nil {
		syscall.Munmap(mmap)
		mapFile.Close()
		return nil, err
	}

	reader.file = mapFile
	return reader, nil
}
Esempio n. 11
0
func NodeStoreWatch(neopath string, ch chan string) {
	file, err := os.Open(neopath + "/neostore.nodestore.db")
	fd := int(file.Fd())
	mmap, err := syscall.Mmap(fd, 0, 100*NODE_SIZE, syscall.PROT_READ, syscall.MAP_SHARED)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	node := NodeRec{}
	mmap_slice := make([]byte, len(mmap))
	copy(mmap_slice, mmap)
	go func() {
		for {
			for i := 0; i < 100; i++ {
				if !bytes.Equal(mmap[i*NODE_SIZE:i*NODE_SIZE+NODE_SIZE], mmap_slice[i*NODE_SIZE:i*NODE_SIZE+NODE_SIZE]) {
					node.Read(uint64(i), mmap)
					fmt.Printf("updated node idx %d: \n", i)
					fmt.Println(node)
				}
			}
			copy(mmap_slice, mmap)
			time.Sleep(time.Millisecond * time.Duration(rand.Int()%100))
		}
	}()
}
Esempio n. 12
0
func main() {
	const n = 4096 * 50 // size of shared memory
	t := int(1) * n
	fmt.Println("Total size of shared memory : ", t)

	// open device file
	mmap_file, err := os.OpenFile(device_file, os.O_RDWR, 0666)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	defer mmap_file.Close()

	// mmap memory
	mmap, err := syscall.Mmap(int(mmap_file.Fd()), 0, int(t),
		syscall.PROT_READ|syscall.PROT_WRITE,
		syscall.MAP_SHARED)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	defer syscall.Munmap(mmap)

	mmap_array := (*[n]byte)(unsafe.Pointer(&mmap[0]))
	fmt.Println(*mmap_array)

	// using memcpy to copy mmap memory buffer into program buffer
	mmap_buf := make([]byte, t)
	copy(mmap_buf, mmap_array[:])
	fmt.Println(mmap_buf)
}
Esempio n. 13
0
func makeMemory(size int, extraProt, extraFlags int) (mem []byte, err error) {
	if size == 0 {
		return
	}

	return syscall.Mmap(-1, 0, size, syscall.PROT_READ|syscall.PROT_WRITE|extraProt, syscall.MAP_PRIVATE|syscall.MAP_ANONYMOUS|extraFlags)
}
Esempio n. 14
0
// mmap memory maps a DB's data file.
func mmap(db *DB, sz int) error {
	// Truncate and fsync to ensure file size metadata is flushed.
	// https://github.com/boltdb/bolt/issues/284
	if !db.NoGrowSync && !db.readOnly {
		if err := db.file.Truncate(int64(sz)); err != nil {
			return fmt.Errorf("file resize error: %s", err)
		}
		if err := db.file.Sync(); err != nil {
			return fmt.Errorf("file sync error: %s", err)
		}
	}

	// Map the data file to memory.
	b, err := syscall.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED)
	if err != nil {
		return err
	}

	// Advise the kernel that the mmap is accessed randomly.
	if err := madvise(b, syscall.MADV_RANDOM); err != nil {
		return fmt.Errorf("madvise: %s", err)
	}

	// Save the original byte slice and convert to a byte array pointer.
	db.dataref = b
	db.data = (*[maxMapSize]byte)(unsafe.Pointer(&b[0]))
	db.datasz = sz
	return nil
}
Esempio n. 15
0
// NewBufferMemoryFs maps a mounted file system into shared memory and returns a handle to the shared memory buffer
func NewBufferMemoryFs(dir string, size, prot int) (Buffer, error) {
	files, err := createBuffer(dir, size)
	if err != nil {
		return nil, err
	}
	file, localFile := files[0], files[1]

	// MAP_NORESERVE is specifically not used because it allows mmap
	// to succeed even when there are no huge pages reserved.
	const flags = syscall.MAP_SHARED | syscall.MAP_POPULATE
	b, err := syscall.Mmap(int(file.Fd()), 0, size, prot, flags)
	if err != nil {
		checkClose(file)
		checkClose(localFile)
		return nil, os.NewSyscallError("NewBufferMemoryFs: mmap", err)
	}

	buf := &sharedBuffer{file, localFile, b, stackToKeep()}

	// Lock everything to avoid SIGBUS when trying to use memory
	// mapped on a tmpfs that becomes full after the Statfs check in
	// createBuffer.
	if err := buf.LockAll(); err != nil {
		checkClose(buf)
		return nil, err
	}

	runtime.SetFinalizer(buf, (*sharedBuffer).finalize)

	return buf, nil
}
Esempio n. 16
0
func openRegion(f *os.File, writeable bool, offset int64) (*region, error) {
	_, err := f.Seek(offset, os.SEEK_SET)
	if err != nil {
		return nil, err
	}
	header := make([]byte, regionHeaderSize)
	_, err = f.Read(header)
	if err != nil {
		return nil, err
	}
	if bytes.Compare(header[:8], signature) != 0 {
		return nil, InvalidSignature
	}
	size := *(*int64)(unsafe.Pointer(&header[regionSizeOffset]))
	rid := *(*int64)(unsafe.Pointer(&header[regionId]))
	flags := syscall.PROT_READ
	if writeable {
		flags |= syscall.PROT_WRITE
	}
	d, err := syscall.Mmap(int(f.Fd()), offset, int(size), flags, syscall.MAP_SHARED)
	if err != nil {
		return nil, err
	}
	r := &region{
		id:                 rid,
		f:                  f,
		d:                  d,
		freePtr:            d[regionFreePointerOffset : regionFreePointerOffset+8],
		blockListNextIdPtr: d[len(d)-8 : len(d)],
	}
	return r, nil
}
Esempio n. 17
0
File: shm.go Progetto: jsgilmore/shm
// NewBufferFile maps a file to shared memory and returns a handle to the shared memory buffer
func NewBufferFile(file *os.File, size, prot int) (Buffer, error) {
	fi, err := file.Stat()
	if err != nil {
		return nil, err
	}
	sys := fi.Sys().(*syscall.Stat_t)
	if sys.Size != int64(size) {
		return nil, errWrongSize
	}

	// Dup to allow file parameter to be closed regardless
	fd, err := syscall.Dup(int(file.Fd()))
	if err != nil {
		return nil, err
	}
	const flags = syscall.MAP_SHARED
	b, err := syscall.Mmap(fd, 0, size, prot, flags)
	if err != nil {
		return nil, err
	}

	// localFile is nil because fd is from somewhere else
	buf := &sharedBuffer{os.NewFile(uintptr(fd), ""), nil, b, stackToKeep()}
	runtime.SetFinalizer(buf, (*sharedBuffer).finalize)

	return buf, nil
}
Esempio n. 18
0
// reload reads back info about b from b.filename.
// b.filename should be set.
func (b *Buffer) reload() error {
	stat, err := os.Stat(b.filename)
	if err != nil {
		return err
	}
	fsize := uint64(stat.Size())
	b.capacity = fsize - metadata

	f, err := os.OpenFile(b.filename, os.O_RDWR, 0600)
	if err != nil {
		return err
	}

	data, err := syscall.Mmap(
		int(f.Fd()), 0, int(fsize),
		syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED,
	)
	if err != nil {
		return err
	}
	b.data = data

	off := int(b.capacity)
	b.first = binary.GetLittleEndianUint64(b.data, off)
	b.last = binary.GetLittleEndianUint64(b.data, off+8)
	b.nextSeq = binary.GetLittleEndianUint64(b.data, off+16)
	b.biggest = binary.GetLittleEndianUint32(b.data, off+24)
	b.length = binary.GetLittleEndianUint64(b.data, off+28)

	return nil
}
Esempio n. 19
0
func NewS4548(path string) *S4548 {

	screen := new(S4548)
	screen.path = path

	var err error
	screen.fp = new(os.File)
	screen.fp, err = os.OpenFile(path, os.O_RDWR, os.ModeDevice|os.ModeCharDevice)
	if err != nil {
		panic(err)
	}

	//screen.fb = make([]uint8, WIDTH*(HEIGHT / 8))
	screen.fb, err = syscall.Mmap(int(screen.fp.Fd()), 0, WIDTH*(HEIGHT/8),
		syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
	if err != nil {
		panic(err)
	}

	p := color.Palette{color.White, color.Black}
	r := image.Rect(0, 0, WIDTH, HEIGHT)
	screen.Paletted = image.NewPaletted(r, p)

	return screen
}
Esempio n. 20
0
File: pal.go Progetto: remerge/gopal
func MMapPal(filename string) (*Pal, error) {
	p := &Pal{}

	fi, err := os.Stat(filename)
	if err != nil {
		return nil, err
	}
	if fi.IsDir() {
		return nil, errors.New(fmt.Sprintf("%s is a directory, file needed", filename))
	}

	file, err := os.OpenFile(filename, os.O_RDWR, 0777)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	mmap, err := syscall.Mmap(int(file.Fd()), 0, int(fi.Size()), syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
	if err != nil {
		return nil, err
	}
	err = p.From(mmap)
	if err != nil {
		syscall.Munmap(mmap)
		return nil, err
	}
	p.mmaped = true
	runtime.SetFinalizer(p, func(p *Pal) {
		p.Free()
	})
	return p, nil
}
Esempio n. 21
0
func New(capacity int, filename string) (*Buffer, error) {
	if _, err := os.Stat(filename); !os.IsNotExist(err) {
		return nil, ErrFileExists
	}

	f, err := os.Create(filename)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	fsize := capacity + metadata
	if err := syscall.Fallocate(int(f.Fd()), 0, 0, int64(fsize)); err != nil {
		return nil, err
	}

	data, err := syscall.Mmap(
		int(f.Fd()), 0, fsize,
		syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED,
	)
	// TODO(ashish): Call msync periodically.
	if err != nil {
		return nil, err
	}

	b := &Buffer{
		capacity: uint64(capacity), // since it's used with uint64s a lot more
		filename: f.Name(),
		data:     data,
	}
	b.updateMeta()

	return b, nil
}
Esempio n. 22
0
func ReadLastNLines(f *os.File, lines int) (string, error) {
	if lines <= 0 {
		return "", fmt.Errorf("invalid line count")
	}

	stat, err := f.Stat()
	if err != nil {
		return "", err
	}

	data, err := syscall.Mmap(int(f.Fd()), 0, int(stat.Size()), syscall.PROT_READ, syscall.MAP_SHARED)
	if err != nil {
		return "", err
	}
	defer syscall.Munmap(data)

	for i := len(data) - 1; i >= 0; i-- {
		if data[i] == '\n' {
			lines--
		}

		if lines < 0 {
			return string(data[i+1 : len(data)]), nil
		}
	}

	return string(data), nil
}
Esempio n. 23
0
func main() {
	// Turn the eventual fault into a panic, not a program crash,
	// so that memcopy can recover.
	debug.SetPanicOnFault(true)

	size := syscall.Getpagesize()

	// Map 16 pages of data with a 4-page hole in the middle.
	data, err := syscall.Mmap(-1, 0, 16*size, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE)
	if err != nil {
		log.Fatalf("mmap: %v", err)
	}

	// Note: Cannot call syscall.Munmap, because Munmap checks
	// that you are unmapping a whole region returned by Mmap.
	// We are trying to unmap just a hole in the middle.
	if _, _, err := syscall.Syscall(syscall.SYS_MUNMAP, uintptr(unsafe.Pointer(&data[8*size])), uintptr(4*size), 0); err != 0 {
		log.Fatalf("munmap: %v", err)
	}

	other := make([]byte, 16*size)

	// Check that memcopy returns the actual amount copied
	// before the fault (8*size - 5, the offset we skip in the argument).
	n, err := memcopy(data[5:], other)
	if err == nil {
		log.Fatal("no error from memcopy across memory hole")
	}
	if n != 8*size-5 {
		log.Fatal("memcopy returned %d, want %d", n, 8*size-5)
	}
}
Esempio n. 24
0
func (mc *mmapCache) MapFile(filename string, count int) (*mmapData, error) {
	mc.Lock()
	defer mc.Unlock()

	// File is already open and mmapped
	md, ok := mc.files[filename]
	if ok {
		return md, nil
	}

	// Open the file
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}

	// Stat the file
	st, err := file.Stat()
	if err != nil {
		return nil, err
	}
	size := int(st.Size())

	// Mmap the file
	data, err := syscall.Mmap(int(file.Fd()), 0, (size+4095) & ^4095, syscall.PROT_READ, syscall.MAP_SHARED)
	if err != nil {
		return nil, err
	}

	// Cache the information and return the mmap
	mc.files[filename] = &mmapData{file: file, data: data, count: count}
	return mc.files[filename], nil
}
Esempio n. 25
0
func initWrite() []node {
	// prepare
	const (
		openFlags = os.O_RDWR
		mmapProts = syscall.PROT_READ | syscall.PROT_WRITE
	)
	// open file
	file, err := os.OpenFile(filePath, openFlags, 0)
	if err != nil {
		panic(fmt.Sprintf("cannot find file '%v' for package 'attr': %v", filePath, err))
	}
	// get file size
	ls, err := file.Stat()
	if err != nil {
		file.Close()
		panic(fmt.Sprintf("cannot lstat file '%v' for package 'attr': %v", filePath, err))
	}
	size := ls.Size()
	// calc node count
	len := size / int64(unsafe.Sizeof(node{}))
	if len > maxLen {
		len = maxLen
	}
	// memory map
	ptr, err := syscall.Mmap(int(file.Fd()), 0, int(size), mmapProts, syscall.MAP_SHARED)
	if err != nil {
		panic(fmt.Sprintf("cannot mmap file '%v'(size=%v) for package 'attr': %v", filePath, size, err))
	}
	return (*[maxLen]node)(unsafe.Pointer(&ptr[0]))[:len]
}
Esempio n. 26
0
File: zim.go Progetto: postfix/gozim
// create a new zim reader
func NewReader(path string, mmap bool) (*ZimReader, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	z := ZimReader{f: f, mainPage: 0xffffffff, layoutPage: 0xffffffff}

	fi, err := f.Stat()
	if err != nil {
		return nil, err
	}

	size := fi.Size()

	if mmap {
		// we need a multiple of page size bigger than the file
		pc := size / int64(os.Getpagesize())
		totalMmap := pc*int64(os.Getpagesize()) + int64(os.Getpagesize())
		if (size % int64(os.Getpagesize())) == 0 {
			totalMmap = size
		}

		mmap, err := syscall.Mmap(int(f.Fd()), 0, int(totalMmap), syscall.PROT_READ, syscall.MAP_PRIVATE)
		if err != nil {
			return nil, err
		}
		z.mmap = mmap
	}

	err = z.readFileHeaders()
	return &z, err
}
Esempio n. 27
0
// Ensure the file ahs room for more data.
func (file *File) Ensure(more uint64) (err error) {
	if file.Append+more <= file.Size {
		return
	}
	if file.Buf != nil {
		if err = syscall.Munmap(file.Buf); err != nil {
			return
		}
	}
	if _, err = file.Fh.Seek(0, os.SEEK_END); err != nil {
		return
	}
	if _, err = file.Fh.Write(make([]byte, file.Growth)); err != nil {
		return
	}
	if err = file.Fh.Sync(); err != nil {
		return
	}
	if newSize := int(file.Size + file.Growth); newSize < 0 {
		log.Panicf("File %s is getting too large", file.Name)
	} else if file.Buf, err = syscall.Mmap(int(file.Fh.Fd()), 0, newSize, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED); err != nil {
		return
	}
	file.Size += file.Growth
	log.Printf("File %s has grown %d bytes\n", file.Name, file.Growth)
	return file.Ensure(more)
}
Esempio n. 28
0
func createMapping(size int) (f *os.File, mem []byte, err error) {
	f, err = ioutil.TempFile("./", "syzkaller-shm")
	if err != nil {
		err = fmt.Errorf("failed to create temp file: %v", err)
		return
	}
	if err = f.Truncate(int64(size)); err != nil {
		err = fmt.Errorf("failed to truncate shm file: %v", err)
		f.Close()
		os.Remove(f.Name())
		return
	}
	f.Close()
	f, err = os.OpenFile(f.Name(), os.O_RDWR, 0)
	if err != nil {
		err = fmt.Errorf("failed to open shm file: %v", err)
		os.Remove(f.Name())
		return
	}
	mem, err = syscall.Mmap(int(f.Fd()), 0, size, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
	if err != nil {
		err = fmt.Errorf("failed to mmap shm file: %v", err)
		f.Close()
		os.Remove(f.Name())
		return
	}
	return
}
Esempio n. 29
0
File: devmem.go Progetto: gyn/mass
func main() {
	var width int
	var value int64

	//
	// check parameters
	//
	argc := len(os.Args)

	if argc < 3 || argc > 4 {
		usage()

		os.Exit(1)
	}

	switch os.Args[2] {
	case "b":
		width = size8bit
	case "h":
		width = size16bit
	case "w":
		width = size32bit
	case "d":
		width = size64bit
	default:
		usage()

		os.Exit(1)
	}

	address := atoInt(os.Args[1])

	if argc == 4 {
		value = atoInt(os.Args[3])
	}

	file, err := os.OpenFile("/dev/mem", fileProt, 0644)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	fd := int(file.Fd())
	base := address &^ pageSizeMask
	offset := address & pageSizeMask

	ptr, err := syscall.Mmap(fd, base, pageSize, mapProt, mapFlag)
	if err != nil {
		log.Fatal(err)
	}

	if argc == 4 {
		writeMem(ptr, width, offset, value)
	}

	addr, data := readMem(ptr, width, offset)

	fmt.Printf("0x%x 0x%x\n", addr+base, data)
}
Esempio n. 30
0
func mmapFile(f *os.File) ([]byte, error) {
	stat, err := f.Stat()
	if err != nil {
		return nil, err
	}

	return syscall.Mmap(int(f.Fd()), 0, int(stat.Size()), syscall.PROT_READ, syscall.MAP_PRIVATE)
}