mmap默认已设置为可读可写

sys/dll_uinx.go

@@ -5,37 +5,7 @@ package sys
 
 import (
 	"errors"
-	"strconv"
 	"unsafe"
-
-	"gtl/cextend"
-)
-
-const (
-	/*
-		重定位是在依赖于实现的时间执行的,范围从 dlopen() 调用时间到对给定符号的第一次引用发生
-		指定 RTLD_LAZY 应该会提高支持动态符号绑定的实现的性能，因为进程可能不会引用任何给定对象中的所有函数
-		而且，对于支持正常流程执行的动态符号解析的系统，此行为模仿流程执行的正常处理。
-	*/
-	RTLD_LAZY = cextend.RTLD_LAZY
-	/*
-		加载对象时执行重定位。
-		首次加载对象时会执行所有必要的重定位。
-		如果对从未引用的函数执行重定位，这可能会浪费一些处理。
-		对于需要在加载对象后立即知道执行期间引用的所有符号都可用的应用程序，此行为可能很有用。
-	*/
-	RTLD_NOW = cextend.RTLD_NOW
-	/*
-		所有符号都可用于其他模块的重定位处理。
-		对象的符号可用于任何其他对象的重定位处理。
-		此外，使用 dlopen ( 0, mode ) 和关联的 dlsym()进行符号查找允许搜索使用此模式 加载的对象 。
-	*/
-	RTLD_GLOBAL = cextend.RTLD_GLOBAL
-	/*
-		并非所有符号都可用于其他模块的重定位处理。
-		对象的符号不可用于任何其他对象的重定位处理。
-	*/
-	RTLD_LOCAL = cextend.RTLD_LOCAL
 )
 
 //动态链接库结构体
@@ -52,35 +22,32 @@ func NewDLL(name string) (d *DLL, err error) {
 //打开一个动态链接库,以指定的mode
 func NewDLLAll(name string, mode int) (d *DLL, err error) {
 	d.name = name
-	d.addr = cextend.Dlopen(name, mode)
+	d.addr = Dlopen(name, mode)
 	if d.addr == nil {
 		return nil, errors.New(cextend.Dlerror())
 	}
 	return
 }
 
 //关闭一个动态链接库
-func (d *DLL) Release() (err int) {
-	ret := cextend.Dlclose(d.addr)
-	return ret
-}
-
-//关闭一个动态链接库
-func (d *DLL) Close() (err int) {
-	ret := cextend.Dlclose(d.addr)
-	return ret
+func (d *DLL) Close() (errint int, err error) {
+	ret := Dlclose(d.addr)
+	if ret != 0 {
+		return ret, errors.New(Dlerror())
+	}
+	return ret, nil
 }
 
 //寻找一个动态链接库中导出的过程
 func (d *DLL) FindProc(name string) (proc uintptr, err error) {
 	var ptr unsafe.Pointer
-	ptr = cextend.Dlsym(d.addr, name)
+	ptr = Dlsym(d.addr, name)
 	if ptr == nil {
 		return 0, errors.New(cextend.Dlerror())
 	}
 	return uintptr(ptr), nil
 }
 
 func (d *DLL) String() string {
-	return d.name + ":so"
+	return d.name + ".so"
 }

sys/dll_windows.go

@@ -31,18 +31,12 @@ func (d *DLL) FindProc(name string) (proc uintptr, err error) {
 	return syscall.GetProcAddress(d.dll, name)
 }
 
-//关闭一个动态链接库
-func (d *DLL) Release() (err error) {
-	syscall.FreeLibrary(d.dll)
-	return
-}
-
 //关闭一个动态链接库
 func (d *DLL) Close() (err error) {
 	syscall.FreeLibrary(d.dll)
 	return
 }
 
 func (d *DLL) String() string {
-	return d.name + ":DLL"
+	return d.name + ".DLL"
 }

sys/doc_uinx_test.go

@@ -1,5 +1,5 @@
-//go:build aix || darwin || freebsd || linux || netbsd || openbsd || solaris || dragonfly
-// +build aix darwin freebsd linux netbsd openbsd solaris dragonfly
+//go:build !windows
+// +build !windows
 
 package sys
 

sys/go.mod

@@ -1,5 +1,3 @@
 module gtl/sys
 
 go 1.16
-
-require golang.org/x/sys v0.0.0-20220412211240-33da011f77ad

sys/go.sum

@@ -1,2 +0,0 @@
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad h1:ntjMns5wyP/fN65tdBD4g8J5w8n015+iIIs9rtjXkY0=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

sys/mmap_uinx.go

@@ -1,23 +1,28 @@
-//go:build aix || darwin || freebsd || linux || netbsd || openbsd || solaris || dragonfly
-// +build aix darwin freebsd linux netbsd openbsd solaris dragonfly
+//go:build !windows
+// +build !windows
 
 package sys
 
 import (
 	"os"
 	"unsafe"
 
-	"golang.org/x/sys/unix"
+	"syscall"
 )
 
 const (
 	//页面可读取
-	READ = unix.PROT_READ
+	READ = syscall.PROT_READ
 	//页面可写入
-	WRITE = unix.PROT_WRITE
-	//页面可执行
-	EXEC = unix.PROT_EXEC
-	RWX  = READ | WRITE | EXEC
+	WRITE = syscall.PROT_WRITE
+	RWX   = READ | WRITE
+)
+
+const (
+	//写入数据复制回文件内，允许其他映射该文件的进程共享
+	SHARED = syscall.MAP_SHARED
+	//写入时复制,写入操作会产生映射文件的复制，对此的任何修改都不会写入文件
+	PRIVATE = syscall.MAP_PRIVATE
 )
 
 //内存映射的结构体
@@ -29,42 +34,25 @@ type Mmap struct {
 
 //以读写模式打开文件，0777权限位，可读可写可执行
 func NewMmap(path string, length int) (m *Mmap, err error) {
-	NewMmapAll(path, os.O_RDWR|os.O_CREATE, 0777, length, RWX, unix.MAP_SHARED)
+	NewMmapAll(path, os.O_RDWR|os.O_CREATE, 0777, length, RWX, SHARED)
 	return
-	/*//打开文件
-	m.file, err = os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0777)
-	if err != nil {
-		return nil, err
-	}
-	//改变文件大小为length
-	err = m.file.Truncate(int64(length))
-	if err != nil {
-		return nil, err
-	}
-	m.length = length
-	//进行系统调用实现共享内存
-	m.memory, err = unix.Mmap(int(m.file.Fd()), 0, length, RWX, unix.MAP_SHARED)
-	if err != nil {
-		return nil, err
-	}
-	return m, nil*/
 }
 
 //以自定义模式与自定义权限位打开文件，自定义是否读写执行
 func NewMmapAll(path string, osflag int, perm os.FileMode, length int, prot int, fileflag int) (m *Mmap, err error) {
 	//打开文件
-	m.file, err = os.OpenFile(path, os, perm)
+	m.file, err = os.OpenFile(path, osflag, perm)
 	if err != nil {
 		return nil, err
 	}
 	//改变文件大小为length
-	_, err = m1.file.Seek(0, 0)
+	_, err = m.file.Seek(0, 0)
 	if err != nil {
 		return nil, err
 	}
 	m.length = length
 	//进行系统调用实现共享内存
-	m.memory, err = unix.Mmap(int(m.file.Fd()), 0, length, prot, fileflag)
+	m.memory, err = syscall.Mmap(int(m.file.Fd()), 0, length, prot, fileflag)
 	if err != nil {
 		return nil, err
 	}
@@ -73,7 +61,7 @@ func NewMmapAll(path string, osflag int, perm os.FileMode, length int, prot int,
 
 //关闭内存映射
 func (m *Mmap) Close() (err error) {
-	err = unix.Munmap(m.memory) //释放已映射空间
+	err = syscall.Munmap(m.memory) //释放已映射空间
 	if err != nil {
 		return err
 	}

sys/mmap_windows.go

@@ -3,35 +3,27 @@ package sys
 import (
 	"os"
 
-	"golang.org/x/sys/windows"
+	"syscall"
 )
 
 const (
 	//页面只读
-	PAGE_READ = windows.PAGE_READONLY
-	//页面可执行
-	PAGE_EXEC = windows.PAGE_EXECUTE
+	PAGE_READ = syscall.PAGE_READONLY
 	//页面读写
-	PAGE_RW = windows.PAGE_READWRITE
+	PAGE_RW = syscall.PAGE_READWRITE
 	//页面可读，可写，可执行
-	PAGE_WX = windows.PAGE_EXECUTE_READ
-	//页面可读，可写
-	PAGE_RWX = PAGE_RW
+	PAGE_RE = syscall.PAGE_EXECUTE_READ
 	//写复制
-	PAGE_WRITECOPY = windows.PAGE_EXECUTE_WRITECOPY
+	PAGE_WRITECOPY = syscall.PAGE_EXECUTE_WRITECOPY
 )
 
 const (
 	//写复制
-	FILE_MAP_COPY = windows.FILE_MAP_COPY
+	FILE_MAP_COPY = syscall.FILE_MAP_COPY
 	//读写
-	FILE_MAP_WRITE = windows.FILE_MAP_WRITE
+	FILE_MAP_WRITE = syscall.FILE_MAP_WRITE
 	//只读
-	FILE_MAP_READ = windows.FILE_MAP_READ
-	//可执行
-	FILE_MAP_EXECUTE = windows.FILE_MAP_EXECUTE
-	//可读，可写，可执行
-	FILE_MAP_RWX = FILE_MAP_WRITE | FILE_MAP_EXECUTE
+	FILE_MAP_READ = syscall.FILE_MAP_READ
 )
 
 var (
@@ -42,46 +34,15 @@ var (
 //内存映射的结构体
 type Mmap struct {
 	file       *os.File
-	mmaphandle windows.Handle
+	mmaphandle Handle
 	length     uint
 	addr       uintptr
 }
 
 //以读写模式打开文件，0777权限位，可读可写
 func NewMmap(path string, length uint) (m *Mmap, err error) {
-	m, err = NewMmapAll(path, os.O_RDWR|os.O_CREATE, 0777, length, PAGE_RWX, FILE_MAP_WRITE)
+	m, err = NewMmapAll(path, os.O_RDWR|os.O_CREATE, 0777, length, PAGE_RW, FILE_MAP_WRITE)
 	return
-	/*//打开文件
-	m.file, err = os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0777)
-	if err != nil {
-		return nil, err
-	}
-	//改变文件大小为length
-	err = m.file.Truncate(int64(length))
-	if err != nil {
-		return nil, err
-	}
-	m.length = length
-	//进行系统调用实现共享内存
-	m.mmaphandle, err = windows.CreateFileMapping(
-		windows.Handle(m.file.Fd()),
-		nil,
-		PAGE_RWX,
-		uint32(length>>32),
-		uint32(length),
-		nil)
-	if err != nil {
-		return nil, err
-	}
-	//使文件大小等于内存页倍数
-	pagelen := length%uint(Pagesize) + 1
-	size := pagelen * Pagesize
-	m.addr, err = windows.MapViewOfFile(m.mmaphandle, FILE_MAP_RWX, 0, 0, uintptr(size))
-	if err != nil {
-		return nil, err
-	}
-	return m, nil
-	*/
 }
 
 //以自定义模式与自定义权限位打开文件，自定义是否读写执行
@@ -99,8 +60,8 @@ func NewMmapAll(path string, osflag int, perm os.FileMode, length uint, prot uin
 	}
 	m1.length = length
 	//进行系统调用实现共享内存
-	m1.mmaphandle, err = windows.CreateFileMapping(
-		windows.Handle(m1.file.Fd()),
+	m1.mmaphandle, err = syscall.CreateFileMapping(
+		Handle(m1.file.Fd()),
 		nil,
 		prot,
 		uint32(length>>32),
@@ -109,7 +70,7 @@ func NewMmapAll(path string, osflag int, perm os.FileMode, length uint, prot uin
 	if err != nil {
 		return nil, err
 	}
-	m1.addr, err = windows.MapViewOfFile(m1.mmaphandle, fileflag, 0, 0, 0)
+	m1.addr, err = syscall.MapViewOfFile(m1.mmaphandle, fileflag, 0, 0, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -119,11 +80,11 @@ func NewMmapAll(path string, osflag int, perm os.FileMode, length uint, prot uin
 
 //关闭内存映射
 func (m *Mmap) Close() (err error) {
-	err = windows.UnmapViewOfFile(m.addr) //释放已映射空间
+	err = syscall.UnmapViewOfFile(m.addr) //释放已映射空间
 	if err != nil {
 		return err
 	}
-	err = windows.CloseHandle(m.mmaphandle) //关闭文件映射对象
+	err = syscall.CloseHandle(m.mmaphandle) //关闭文件映射对象
 	if err != nil {
 		return err
 	}

cextend/so_unix.go → sys/so_unix.go

@@ -1,12 +1,15 @@
 //go:build !windows
 // +build !windows
 
-package cextend
+package sys
 
 import (
 	"unsafe"
 )
 
+// #cgo CFLAGS: -g -O3 -march=corei7
+// #cgo LDFLAGS: -ldl
+
 /*
 	#include <dlfcn.h>
 */