// +build !cgo,windows /* * host_nocgo_windows.go * * Copyright 2017-2018 Bill Zissimopoulos */ /* * This file is part of Cgofuse. * * It is licensed under the MIT license. The full license text can be found * in the License.txt file at the root of this project. */ package fuse import ( "path/filepath" "sync" "syscall" "unsafe" ) type align64 uint32 // align to 64-bits (necessary when compiling for 32bit; see golang/go#599) type fuse_operations struct { getattr uintptr getdir uintptr readlink uintptr mknod uintptr mkdir uintptr unlink uintptr rmdir uintptr symlink uintptr rename uintptr link uintptr chmod uintptr chown uintptr truncate uintptr utime uintptr open uintptr read uintptr write uintptr statfs uintptr flush uintptr release uintptr fsync uintptr setxattr uintptr getxattr uintptr listxattr uintptr removexattr uintptr opendir uintptr readdir uintptr releasedir uintptr fsyncdir uintptr init uintptr destroy uintptr access uintptr create uintptr ftruncate uintptr fgetattr uintptr lock uintptr utimens uintptr bmap uintptr flags uint32 ioctl uintptr poll uintptr write_buf uintptr read_buf uintptr flock uintptr fallocate uintptr reserved00 uintptr reserved01 uintptr reserved02 uintptr statfs_x uintptr setvolname uintptr exchange uintptr getxtimes uintptr setbkuptime uintptr setchgtime uintptr setcrtime uintptr chflags uintptr setattr_x uintptr fsetattr_x uintptr } type fuse_stat_t struct { st_dev c_fuse_dev_t _ align64 st_ino c_fuse_ino_t st_mode c_fuse_mode_t st_nlink c_fuse_nlink_t st_uid c_fuse_uid_t st_gid c_fuse_gid_t st_rdev c_fuse_dev_t _ align64 st_size c_fuse_off_t st_atim c_fuse_timespec_t st_mtim c_fuse_timespec_t st_ctim c_fuse_timespec_t st_blksize c_fuse_blksize_t _ align64 st_blocks c_fuse_blkcnt_t st_birthtim c_fuse_timespec_t } type fuse_stat_ex_t struct { fuse_stat_t st_flags c_uint32_t st_reserved32 [3]c_uint32_t st_reserved64 [2]c_uint64_t } type fuse_statvfs_t struct { f_bsize uintptr f_frsize uintptr f_blocks c_fuse_fsblkcnt_t f_bfree c_fuse_fsblkcnt_t f_bavail c_fuse_fsblkcnt_t f_files c_fuse_fsfilcnt_t f_ffree c_fuse_fsfilcnt_t f_favail c_fuse_fsfilcnt_t f_fsid uintptr f_flag uintptr f_namemax uintptr } type fuse_timespec_t struct { tv_sec uintptr tv_nsec uintptr } type struct_fuse struct { _ struct{} } type struct_fuse_args struct { argc c_int argv **c_char allocated c_int } type struct_fuse_conn_info struct { proto_major c_unsigned proto_minor c_unsigned async_read c_unsigned max_write c_unsigned max_readahead c_unsigned capable c_unsigned want c_unsigned reserved [25]c_unsigned } type struct_fuse_context struct { fuse *c_struct_fuse uid c_fuse_uid_t gid c_fuse_gid_t pid c_fuse_pid_t private_data unsafe.Pointer umask c_fuse_mode_t } type struct_fuse_file_info struct { flags c_int fh_old c_unsigned writepage c_int bits c_uint32_t fh c_uint64_t lock_owner c_uint64_t } type struct_fuse_opt struct { templ *c_char offset c_fuse_opt_offset_t value c_int } type ( c_bool = bool c_char = byte c_fuse_blkcnt_t = int64 c_fuse_blksize_t = int32 c_fuse_dev_t = uint32 c_fuse_fill_dir_t = uintptr c_fuse_fsblkcnt_t = uintptr c_fuse_fsfilcnt_t = uintptr c_fuse_gid_t = uint32 c_fuse_ino_t = uint64 c_fuse_mode_t = uint32 c_fuse_nlink_t = uint16 c_fuse_off_t = int64 c_fuse_opt_offset_t = uint32 c_fuse_pid_t = int32 c_fuse_stat_t = fuse_stat_t c_fuse_stat_ex_t = fuse_stat_ex_t c_fuse_statvfs_t = fuse_statvfs_t c_fuse_timespec_t = fuse_timespec_t c_fuse_uid_t = uint32 c_int = int32 c_int16_t = int16 c_int32_t = int32 c_int64_t = int64 c_int8_t = int8 c_size_t = uintptr c_struct_fuse = struct_fuse c_struct_fuse_args = struct_fuse_args c_struct_fuse_conn_info = struct_fuse_conn_info c_struct_fuse_context = struct_fuse_context c_struct_fuse_file_info = struct_fuse_file_info c_struct_fuse_opt = struct_fuse_opt c_uint16_t = uint16 c_uint32_t = uint32 c_uint64_t = uint64 c_uint8_t = uint8 c_uintptr_t = uintptr c_unsigned = uint32 ) var ( kernel32 = syscall.MustLoadDLL("kernel32.dll") getProcessHeap = kernel32.MustFindProc("GetProcessHeap") heapAlloc = kernel32.MustFindProc("HeapAlloc") heapFree = kernel32.MustFindProc("HeapFree") processHeap uintptr /* * It appears safe to call cdecl functions from Go. Is it really? * https://codereview.appspot.com/4961045/ */ fuseOnce sync.Once fuseDll *syscall.DLL fuse_version *syscall.Proc fuse_mount *syscall.Proc fuse_unmount *syscall.Proc fuse_parse_cmdline *syscall.Proc fuse_main_real *syscall.Proc fuse_is_lib_option *syscall.Proc fuse_new *syscall.Proc fuse_destroy *syscall.Proc fuse_loop *syscall.Proc fuse_loop_mt *syscall.Proc fuse_exit *syscall.Proc fuse_get_context *syscall.Proc fuse_opt_parse *syscall.Proc fuse_opt_add_arg *syscall.Proc fuse_opt_insert_arg *syscall.Proc fuse_opt_free_args *syscall.Proc fuse_opt_add_opt *syscall.Proc fuse_opt_add_opt_escaped *syscall.Proc fuse_opt_match *syscall.Proc hostOptParseOptProc = syscall.NewCallbackCDecl(c_hostOptParseOptProc) cgofuse_stat_ex bool ) const ( FSP_FUSE_CAP_CASE_INSENSITIVE = 1 << 29 FSP_FUSE_CAP_READDIR_PLUS = 1 << 21 FSP_FUSE_CAP_STAT_EX = 1 << 23 FUSE_OPT_KEY_NONOPT = -2 ) func init() { processHeap, _, _ = getProcessHeap.Call() } func c_GoString(s *c_char) string { if nil == s { return "" } q := (*[1 << 30]c_char)(unsafe.Pointer(s)) l := 0 for 0 != q[l] { l++ } return string(q[:l]) } func c_CString(s string) *c_char { p := c_malloc(c_size_t(len(s) + 1)) q := (*[1 << 30]c_char)(p) copy(q[:], s) q[len(s)] = 0 return (*c_char)(p) } func c_malloc(size c_size_t) unsafe.Pointer { p, _, _ := heapAlloc.Call(processHeap, 0, size) if 0 == p { panic("runtime: C malloc failed") } return unsafe.Pointer(p) } func c_calloc(count c_size_t, size c_size_t) unsafe.Pointer { p, _, _ := heapAlloc.Call(processHeap, 8 /*HEAP_ZERO_MEMORY*/, count*size) return unsafe.Pointer(p) } func c_free(p unsafe.Pointer) { if nil != p { heapFree.Call(processHeap, 0, uintptr(p)) } } func c_fuse_get_context() *c_struct_fuse_context { p, _, _ := fuse_get_context.Call() return (*c_struct_fuse_context)(unsafe.Pointer(p)) } func c_fuse_opt_free_args(args *c_struct_fuse_args) { fuse_opt_free_args.Call(uintptr(unsafe.Pointer(args))) } func c_hostAsgnCconninfo(conn *c_struct_fuse_conn_info, capCaseInsensitive c_bool, capReaddirPlus c_bool) { conn.want |= conn.capable & FSP_FUSE_CAP_STAT_EX cgofuse_stat_ex = 0 != conn.want&FSP_FUSE_CAP_STAT_EX // hack! if capCaseInsensitive { conn.want |= conn.capable & FSP_FUSE_CAP_CASE_INSENSITIVE } if capReaddirPlus { conn.want |= conn.capable & FSP_FUSE_CAP_READDIR_PLUS } } func c_hostCstatvfsFromFusestatfs(stbuf *c_fuse_statvfs_t, bsize c_uint64_t, frsize c_uint64_t, blocks c_uint64_t, bfree c_uint64_t, bavail c_uint64_t, files c_uint64_t, ffree c_uint64_t, favail c_uint64_t, fsid c_uint64_t, flag c_uint64_t, namemax c_uint64_t) { *stbuf = c_fuse_statvfs_t{ f_bsize: uintptr(bsize), f_frsize: uintptr(frsize), f_blocks: c_fuse_fsblkcnt_t(blocks), f_bfree: c_fuse_fsblkcnt_t(bfree), f_bavail: c_fuse_fsblkcnt_t(bavail), f_files: c_fuse_fsfilcnt_t(files), f_ffree: c_fuse_fsfilcnt_t(ffree), f_favail: c_fuse_fsfilcnt_t(favail), f_fsid: uintptr(fsid), f_flag: uintptr(flag), f_namemax: uintptr(namemax), } } func c_hostCstatFromFusestat(stbuf *c_fuse_stat_t, dev c_uint64_t, ino c_uint64_t, mode c_uint32_t, nlink c_uint32_t, uid c_uint32_t, gid c_uint32_t, rdev c_uint64_t, size c_int64_t, atimSec c_int64_t, atimNsec c_int64_t, mtimSec c_int64_t, mtimNsec c_int64_t, ctimSec c_int64_t, ctimNsec c_int64_t, blksize c_int64_t, blocks c_int64_t, birthtimSec c_int64_t, birthtimNsec c_int64_t, flags c_uint32_t) { if !cgofuse_stat_ex { *stbuf = c_fuse_stat_t{ st_dev: c_fuse_dev_t(dev), st_ino: c_fuse_ino_t(ino), st_mode: c_fuse_mode_t(mode), st_nlink: c_fuse_nlink_t(nlink), st_uid: c_fuse_uid_t(uid), st_gid: c_fuse_gid_t(gid), st_rdev: c_fuse_dev_t(rdev), st_size: c_fuse_off_t(size), st_blksize: c_fuse_blksize_t(blksize), st_blocks: c_fuse_blkcnt_t(blocks), st_atim: c_fuse_timespec_t{ tv_sec: uintptr(atimSec), tv_nsec: uintptr(atimNsec), }, st_mtim: c_fuse_timespec_t{ tv_sec: uintptr(mtimSec), tv_nsec: uintptr(mtimNsec), }, st_ctim: c_fuse_timespec_t{ tv_sec: uintptr(ctimSec), tv_nsec: uintptr(ctimNsec), }, } } else { *(*fuse_stat_ex_t)(unsafe.Pointer(stbuf)) = fuse_stat_ex_t{ fuse_stat_t: c_fuse_stat_t{ st_dev: c_fuse_dev_t(dev), st_ino: c_fuse_ino_t(ino), st_mode: c_fuse_mode_t(mode), st_nlink: c_fuse_nlink_t(nlink), st_uid: c_fuse_uid_t(uid), st_gid: c_fuse_gid_t(gid), st_rdev: c_fuse_dev_t(rdev), st_size: c_fuse_off_t(size), st_blksize: c_fuse_blksize_t(blksize), st_blocks: c_fuse_blkcnt_t(blocks), st_atim: c_fuse_timespec_t{ tv_sec: uintptr(atimSec), tv_nsec: uintptr(atimNsec), }, st_mtim: c_fuse_timespec_t{ tv_sec: uintptr(mtimSec), tv_nsec: uintptr(mtimNsec), }, st_ctim: c_fuse_timespec_t{ tv_sec: uintptr(ctimSec), tv_nsec: uintptr(ctimNsec), }, }, st_flags: flags, } } if 0 != birthtimSec { stbuf.st_birthtim.tv_sec = uintptr(birthtimSec) stbuf.st_birthtim.tv_nsec = uintptr(birthtimNsec) } else { stbuf.st_birthtim.tv_sec = uintptr(ctimSec) stbuf.st_birthtim.tv_nsec = uintptr(ctimNsec) } } func c_hostFilldir(filler c_fuse_fill_dir_t, buf unsafe.Pointer, name *c_char, stbuf *c_fuse_stat_t, off c_fuse_off_t) c_int { var r uintptr if uint64(0xffffffff) < uint64(^uintptr(0)) { r, _, _ = syscall.Syscall6(filler, 4, uintptr(buf), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(stbuf)), uintptr(off), 0, 0) } else { r, _, _ = syscall.Syscall6(filler, 5, uintptr(buf), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(stbuf)), uintptr(off), uintptr(off>>32), 0) } return c_int(r) } func c_hostStaticInit() { } func c_hostFuseInit() c_int { fuseOnce.Do(func() { fuseDll, _ = fspload() if nil != fuseDll { fuse_version = fuseDll.MustFindProc("fuse_version") fuse_mount = fuseDll.MustFindProc("fuse_mount") fuse_unmount = fuseDll.MustFindProc("fuse_unmount") fuse_parse_cmdline = fuseDll.MustFindProc("fuse_parse_cmdline") fuse_main_real = fuseDll.MustFindProc("fuse_main_real") fuse_is_lib_option = fuseDll.MustFindProc("fuse_is_lib_option") fuse_new = fuseDll.MustFindProc("fuse_new") fuse_destroy = fuseDll.MustFindProc("fuse_destroy") fuse_loop = fuseDll.MustFindProc("fuse_loop") fuse_loop_mt = fuseDll.MustFindProc("fuse_loop_mt") fuse_exit = fuseDll.MustFindProc("fuse_exit") fuse_get_context = fuseDll.MustFindProc("fuse_get_context") fuse_opt_parse = fuseDll.MustFindProc("fuse_opt_parse") fuse_opt_add_arg = fuseDll.MustFindProc("fuse_opt_add_arg") fuse_opt_insert_arg = fuseDll.MustFindProc("fuse_opt_insert_arg") fuse_opt_free_args = fuseDll.MustFindProc("fuse_opt_free_args") fuse_opt_add_opt = fuseDll.MustFindProc("fuse_opt_add_opt") fuse_opt_add_opt_escaped = fuseDll.MustFindProc("fuse_opt_add_opt_escaped") fuse_opt_match = fuseDll.MustFindProc("fuse_opt_match") } }) if nil == fuseDll { return 0 } return 1 } func c_hostMount(argc c_int, argv **c_char, data unsafe.Pointer) c_int { r, _, _ := fuse_main_real.Call( uintptr(argc), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(&fsop)), unsafe.Sizeof(fsop), uintptr(data)) if 0 == r { return 1 } return 0 } func c_hostUnmount(fuse *c_struct_fuse, mountpoint *c_char) c_int { fuse_exit.Call(uintptr(unsafe.Pointer(fuse))) return 1 } func c_hostOptSet(opt *c_struct_fuse_opt, templ *c_char, offset c_fuse_opt_offset_t, value c_int) { *opt = c_struct_fuse_opt{ templ: templ, offset: offset, value: value, } } func c_hostOptParseOptProc(opt_data uintptr, arg uintptr, key uintptr, outargs uintptr) uintptr { switch c_int(key) { default: return 0 case FUSE_OPT_KEY_NONOPT: return 1 } } func c_hostOptParse(args *c_struct_fuse_args, data unsafe.Pointer, opts *c_struct_fuse_opt, nonopts c_bool) c_int { var callback uintptr if nonopts { callback = hostOptParseOptProc } r, _, _ := fuse_opt_parse.Call( uintptr(unsafe.Pointer(args)), uintptr(data), uintptr(unsafe.Pointer(opts)), callback) return c_int(r) } func fspload() (dll *syscall.DLL, err error) { dllname := "" if uint64(0xffffffff) < uint64(^uintptr(0)) { dllname = "winfsp-x64.dll" } else { dllname = "winfsp-x86.dll" } dll, err = syscall.LoadDLL(dllname) if nil == dll { var pathbuf [syscall.MAX_PATH]uint16 var regkey syscall.Handle var regtype, size uint32 kname, _ := syscall.UTF16PtrFromString("Software\\WinFsp") err = syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, kname, 0, syscall.KEY_READ|syscall.KEY_WOW64_32KEY, ®key) if nil != err { err = syscall.ERROR_MOD_NOT_FOUND return } vname, _ := syscall.UTF16PtrFromString("InstallDir") size = uint32(len(pathbuf) * 2) err = syscall.RegQueryValueEx(regkey, vname, nil, ®type, (*byte)(unsafe.Pointer(&pathbuf)), &size) syscall.RegCloseKey(regkey) if nil != err || syscall.REG_SZ != regtype { err = syscall.ERROR_MOD_NOT_FOUND return } if 0 < size && 0 == pathbuf[size/2-1] { size -= 2 } path := syscall.UTF16ToString(pathbuf[:size/2]) dllpath := filepath.Join(path, "bin", dllname) dll, err = syscall.LoadDLL(dllpath) if nil != err { err = syscall.ERROR_MOD_NOT_FOUND return } } return } var fsop fuse_operations func init() { const intSize = 32 + int(^uintptr(0)>>63<<5) if uint64(0xffffffff) < uint64(^uintptr(0)) { fsop = fuse_operations{ getattr: syscall.NewCallbackCDecl(go_hostGetattr64), readlink: syscall.NewCallbackCDecl(go_hostReadlink64), mknod: syscall.NewCallbackCDecl(go_hostMknod64), mkdir: syscall.NewCallbackCDecl(go_hostMkdir64), unlink: syscall.NewCallbackCDecl(go_hostUnlink64), rmdir: syscall.NewCallbackCDecl(go_hostRmdir64), symlink: syscall.NewCallbackCDecl(go_hostSymlink64), rename: syscall.NewCallbackCDecl(go_hostRename64), link: syscall.NewCallbackCDecl(go_hostLink64), chmod: syscall.NewCallbackCDecl(go_hostChmod64), chown: syscall.NewCallbackCDecl(go_hostChown64), truncate: syscall.NewCallbackCDecl(go_hostTruncate64), open: syscall.NewCallbackCDecl(go_hostOpen64), read: syscall.NewCallbackCDecl(go_hostRead64), write: syscall.NewCallbackCDecl(go_hostWrite64), statfs: syscall.NewCallbackCDecl(go_hostStatfs64), flush: syscall.NewCallbackCDecl(go_hostFlush64), release: syscall.NewCallbackCDecl(go_hostRelease64), fsync: syscall.NewCallbackCDecl(go_hostFsync64), setxattr: syscall.NewCallbackCDecl(go_hostSetxattr64), getxattr: syscall.NewCallbackCDecl(go_hostGetxattr64), listxattr: syscall.NewCallbackCDecl(go_hostListxattr64), removexattr: syscall.NewCallbackCDecl(go_hostRemovexattr64), opendir: syscall.NewCallbackCDecl(go_hostOpendir64), readdir: syscall.NewCallbackCDecl(go_hostReaddir64), releasedir: syscall.NewCallbackCDecl(go_hostReleasedir64), fsyncdir: syscall.NewCallbackCDecl(go_hostFsyncdir64), init: syscall.NewCallbackCDecl(go_hostInit64), destroy: syscall.NewCallbackCDecl(go_hostDestroy64), access: syscall.NewCallbackCDecl(go_hostAccess64), create: syscall.NewCallbackCDecl(go_hostCreate64), ftruncate: syscall.NewCallbackCDecl(go_hostFtruncate64), fgetattr: syscall.NewCallbackCDecl(go_hostFgetattr64), utimens: syscall.NewCallbackCDecl(go_hostUtimens64), setchgtime: syscall.NewCallbackCDecl(go_hostSetchgtime64), setcrtime: syscall.NewCallbackCDecl(go_hostSetcrtime64), chflags: syscall.NewCallbackCDecl(go_hostChflags64), } } else { fsop = fuse_operations{ getattr: syscall.NewCallbackCDecl(go_hostGetattr32), readlink: syscall.NewCallbackCDecl(go_hostReadlink32), mknod: syscall.NewCallbackCDecl(go_hostMknod32), mkdir: syscall.NewCallbackCDecl(go_hostMkdir32), unlink: syscall.NewCallbackCDecl(go_hostUnlink32), rmdir: syscall.NewCallbackCDecl(go_hostRmdir32), symlink: syscall.NewCallbackCDecl(go_hostSymlink32), rename: syscall.NewCallbackCDecl(go_hostRename32), link: syscall.NewCallbackCDecl(go_hostLink32), chmod: syscall.NewCallbackCDecl(go_hostChmod32), chown: syscall.NewCallbackCDecl(go_hostChown32), truncate: syscall.NewCallbackCDecl(go_hostTruncate32), open: syscall.NewCallbackCDecl(go_hostOpen32), read: syscall.NewCallbackCDecl(go_hostRead32), write: syscall.NewCallbackCDecl(go_hostWrite32), statfs: syscall.NewCallbackCDecl(go_hostStatfs32), flush: syscall.NewCallbackCDecl(go_hostFlush32), release: syscall.NewCallbackCDecl(go_hostRelease32), fsync: syscall.NewCallbackCDecl(go_hostFsync32), setxattr: syscall.NewCallbackCDecl(go_hostSetxattr32), getxattr: syscall.NewCallbackCDecl(go_hostGetxattr32), listxattr: syscall.NewCallbackCDecl(go_hostListxattr32), removexattr: syscall.NewCallbackCDecl(go_hostRemovexattr32), opendir: syscall.NewCallbackCDecl(go_hostOpendir32), readdir: syscall.NewCallbackCDecl(go_hostReaddir32), releasedir: syscall.NewCallbackCDecl(go_hostReleasedir32), fsyncdir: syscall.NewCallbackCDecl(go_hostFsyncdir32), init: syscall.NewCallbackCDecl(go_hostInit32), destroy: syscall.NewCallbackCDecl(go_hostDestroy32), access: syscall.NewCallbackCDecl(go_hostAccess32), create: syscall.NewCallbackCDecl(go_hostCreate32), ftruncate: syscall.NewCallbackCDecl(go_hostFtruncate32), fgetattr: syscall.NewCallbackCDecl(go_hostFgetattr32), utimens: syscall.NewCallbackCDecl(go_hostUtimens32), setchgtime: syscall.NewCallbackCDecl(go_hostSetchgtime32), setcrtime: syscall.NewCallbackCDecl(go_hostSetcrtime32), chflags: syscall.NewCallbackCDecl(go_hostChflags32), } } } // 64-bit func go_hostGetattr64(path0 *c_char, stat0 *c_fuse_stat_t) (errc0 uintptr) { return uintptr(int(hostGetattr(path0, stat0))) } func go_hostReadlink64(path0 *c_char, buff0 *c_char, size0 uintptr) (errc0 uintptr) { return uintptr(int(hostReadlink(path0, buff0, c_size_t(size0)))) } func go_hostMknod64(path0 *c_char, mode0 uintptr, dev0 uintptr) (errc0 uintptr) { return uintptr(int(hostMknod(path0, c_fuse_mode_t(mode0), c_fuse_dev_t(dev0)))) } func go_hostMkdir64(path0 *c_char, mode0 uintptr) (errc0 uintptr) { return uintptr(int(hostMkdir(path0, c_fuse_mode_t(mode0)))) } func go_hostUnlink64(path0 *c_char) (errc0 uintptr) { return uintptr(int(hostUnlink(path0))) } func go_hostRmdir64(path0 *c_char) (errc0 uintptr) { return uintptr(int(hostRmdir(path0))) } func go_hostSymlink64(target0 *c_char, newpath0 *c_char) (errc0 uintptr) { return uintptr(int(hostSymlink(target0, newpath0))) } func go_hostRename64(oldpath0 *c_char, newpath0 *c_char) (errc0 uintptr) { return uintptr(int(hostRename(oldpath0, newpath0))) } func go_hostLink64(oldpath0 *c_char, newpath0 *c_char) (errc0 uintptr) { return uintptr(int(hostLink(oldpath0, newpath0))) } func go_hostChmod64(path0 *c_char, mode0 uintptr) (errc0 uintptr) { return uintptr(int(hostChmod(path0, c_fuse_mode_t(mode0)))) } func go_hostChown64(path0 *c_char, uid0 uintptr, gid0 uintptr) (errc0 uintptr) { return uintptr(int(hostChown(path0, c_fuse_uid_t(uid0), c_fuse_gid_t(gid0)))) } func go_hostTruncate64(path0 *c_char, size0 uintptr) (errc0 uintptr) { return uintptr(int(hostTruncate(path0, c_fuse_off_t(size0)))) } func go_hostOpen64(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostOpen(path0, fi0))) } func go_hostRead64(path0 *c_char, buff0 *c_char, size0 uintptr, ofst0 uintptr, fi0 *c_struct_fuse_file_info) (nbyt0 uintptr) { return uintptr(int(hostRead(path0, buff0, c_size_t(size0), c_fuse_off_t(ofst0), fi0))) } func go_hostWrite64(path0 *c_char, buff0 *c_char, size0 c_size_t, ofst0 c_fuse_off_t, fi0 *c_struct_fuse_file_info) (nbyt0 uintptr) { return uintptr(int(hostWrite(path0, buff0, c_size_t(size0), c_fuse_off_t(ofst0), fi0))) } func go_hostStatfs64(path0 *c_char, stat0 *c_fuse_statvfs_t) (errc0 uintptr) { return uintptr(int(hostStatfs(path0, stat0))) } func go_hostFlush64(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFlush(path0, fi0))) } func go_hostRelease64(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostRelease(path0, fi0))) } func go_hostFsync64(path0 *c_char, datasync c_int, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFsync(path0, c_int(datasync), fi0))) } func go_hostSetxattr64(path0 *c_char, name0 *c_char, buff0 *c_char, size0 uintptr, flags uintptr) (errc0 uintptr) { return uintptr(int(hostSetxattr(path0, name0, buff0, c_size_t(size0), c_int(flags)))) } func go_hostGetxattr64(path0 *c_char, name0 *c_char, buff0 *c_char, size0 uintptr) (nbyt0 uintptr) { return uintptr(int(hostGetxattr(path0, name0, buff0, c_size_t(size0)))) } func go_hostListxattr64(path0 *c_char, buff0 *c_char, size0 uintptr) (nbyt0 uintptr) { return uintptr(int(hostListxattr(path0, buff0, c_size_t(size0)))) } func go_hostRemovexattr64(path0 *c_char, name0 *c_char) (errc0 uintptr) { return uintptr(int(hostRemovexattr(path0, name0))) } func go_hostOpendir64(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostOpendir(path0, fi0))) } func go_hostReaddir64(path0 *c_char, buff0 unsafe.Pointer, fill0 c_fuse_fill_dir_t, ofst0 uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostReaddir(path0, buff0, fill0, c_fuse_off_t(ofst0), fi0))) } func go_hostReleasedir64(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostReleasedir(path0, fi0))) } func go_hostFsyncdir64(path0 *c_char, datasync uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFsyncdir(path0, c_int(datasync), fi0))) } func go_hostInit64(conn0 *c_struct_fuse_conn_info) (user_data unsafe.Pointer) { return hostInit(conn0) } func go_hostDestroy64(user_data unsafe.Pointer) uintptr { hostDestroy(user_data) return 0 } func go_hostAccess64(path0 *c_char, mask0 uintptr) (errc0 uintptr) { return uintptr(int(hostAccess(path0, c_int(mask0)))) } func go_hostCreate64(path0 *c_char, mode0 uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostCreate(path0, c_fuse_mode_t(mode0), fi0))) } func go_hostFtruncate64(path0 *c_char, size0 uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFtruncate(path0, c_fuse_off_t(size0), fi0))) } func go_hostFgetattr64(path0 *c_char, stat0 *c_fuse_stat_t, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFgetattr(path0, stat0, fi0))) } func go_hostUtimens64(path0 *c_char, tmsp0 *c_fuse_timespec_t) (errc0 uintptr) { return uintptr(int(hostUtimens(path0, tmsp0))) } func go_hostSetchgtime64(path0 *c_char, tmsp0 *c_fuse_timespec_t) (errc0 uintptr) { return uintptr(int(hostSetchgtime(path0, tmsp0))) } func go_hostSetcrtime64(path0 *c_char, tmsp0 *c_fuse_timespec_t) (errc0 uintptr) { return uintptr(int(hostSetcrtime(path0, tmsp0))) } func go_hostChflags64(path0 *c_char, flags c_uint32_t) (errc0 uintptr) { return uintptr(int(hostChflags(path0, flags))) } // 32-bit func go_hostGetattr32(path0 *c_char, stat0 *c_fuse_stat_t) (errc0 uintptr) { return uintptr(int(hostGetattr(path0, stat0))) } func go_hostReadlink32(path0 *c_char, buff0 *c_char, size0 uintptr) (errc0 uintptr) { return uintptr(int(hostReadlink(path0, buff0, c_size_t(size0)))) } func go_hostMknod32(path0 *c_char, mode0 uintptr, dev0 uintptr) (errc0 uintptr) { return uintptr(int(hostMknod(path0, c_fuse_mode_t(mode0), c_fuse_dev_t(dev0)))) } func go_hostMkdir32(path0 *c_char, mode0 uintptr) (errc0 uintptr) { return uintptr(int(hostMkdir(path0, c_fuse_mode_t(mode0)))) } func go_hostUnlink32(path0 *c_char) (errc0 uintptr) { return uintptr(int(hostUnlink(path0))) } func go_hostRmdir32(path0 *c_char) (errc0 uintptr) { return uintptr(int(hostRmdir(path0))) } func go_hostSymlink32(target0 *c_char, newpath0 *c_char) (errc0 uintptr) { return uintptr(int(hostSymlink(target0, newpath0))) } func go_hostRename32(oldpath0 *c_char, newpath0 *c_char) (errc0 uintptr) { return uintptr(int(hostRename(oldpath0, newpath0))) } func go_hostLink32(oldpath0 *c_char, newpath0 *c_char) (errc0 uintptr) { return uintptr(int(hostLink(oldpath0, newpath0))) } func go_hostChmod32(path0 *c_char, mode0 uintptr) (errc0 uintptr) { return uintptr(int(hostChmod(path0, c_fuse_mode_t(mode0)))) } func go_hostChown32(path0 *c_char, uid0 uintptr, gid0 uintptr) (errc0 uintptr) { return uintptr(int(hostChown(path0, c_fuse_uid_t(uid0), c_fuse_gid_t(gid0)))) } func go_hostTruncate32(path0 *c_char, lsize0, hsize0 uintptr) (errc0 uintptr) { return uintptr(int(hostTruncate(path0, (c_fuse_off_t(hsize0)<<32)|c_fuse_off_t(lsize0)))) } func go_hostOpen32(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostOpen(path0, fi0))) } func go_hostRead32(path0 *c_char, buff0 *c_char, size0 uintptr, lofst0, hofst0 uintptr, fi0 *c_struct_fuse_file_info) (nbyt0 uintptr) { return uintptr(int(hostRead(path0, buff0, c_size_t(size0), (c_fuse_off_t(hofst0)<<32)|c_fuse_off_t(lofst0), fi0))) } func go_hostWrite32(path0 *c_char, buff0 *c_char, size0 c_size_t, lofst0, hofst0 uintptr, fi0 *c_struct_fuse_file_info) (nbyt0 uintptr) { return uintptr(int(hostWrite(path0, buff0, c_size_t(size0), (c_fuse_off_t(hofst0)<<32)|c_fuse_off_t(lofst0), fi0))) } func go_hostStatfs32(path0 *c_char, stat0 *c_fuse_statvfs_t) (errc0 uintptr) { return uintptr(int(hostStatfs(path0, stat0))) } func go_hostFlush32(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFlush(path0, fi0))) } func go_hostRelease32(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostRelease(path0, fi0))) } func go_hostFsync32(path0 *c_char, datasync c_int, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFsync(path0, c_int(datasync), fi0))) } func go_hostSetxattr32(path0 *c_char, name0 *c_char, buff0 *c_char, size0 uintptr, flags uintptr) (errc0 uintptr) { return uintptr(int(hostSetxattr(path0, name0, buff0, c_size_t(size0), c_int(flags)))) } func go_hostGetxattr32(path0 *c_char, name0 *c_char, buff0 *c_char, size0 uintptr) (nbyt0 uintptr) { return uintptr(int(hostGetxattr(path0, name0, buff0, c_size_t(size0)))) } func go_hostListxattr32(path0 *c_char, buff0 *c_char, size0 uintptr) (nbyt0 uintptr) { return uintptr(int(hostListxattr(path0, buff0, c_size_t(size0)))) } func go_hostRemovexattr32(path0 *c_char, name0 *c_char) (errc0 uintptr) { return uintptr(int(hostRemovexattr(path0, name0))) } func go_hostOpendir32(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostOpendir(path0, fi0))) } func go_hostReaddir32(path0 *c_char, buff0 unsafe.Pointer, fill0 c_fuse_fill_dir_t, lofst0, hofst0 uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostReaddir(path0, buff0, fill0, (c_fuse_off_t(hofst0)<<32)|c_fuse_off_t(lofst0), fi0))) } func go_hostReleasedir32(path0 *c_char, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostReleasedir(path0, fi0))) } func go_hostFsyncdir32(path0 *c_char, datasync uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFsyncdir(path0, c_int(datasync), fi0))) } func go_hostInit32(conn0 *c_struct_fuse_conn_info) (user_data unsafe.Pointer) { return hostInit(conn0) } func go_hostDestroy32(user_data unsafe.Pointer) uintptr { hostDestroy(user_data) return 0 } func go_hostAccess32(path0 *c_char, mask0 uintptr) (errc0 uintptr) { return uintptr(int(hostAccess(path0, c_int(mask0)))) } func go_hostCreate32(path0 *c_char, mode0 uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostCreate(path0, c_fuse_mode_t(mode0), fi0))) } func go_hostFtruncate32(path0 *c_char, lsize0, hsize0 uintptr, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFtruncate(path0, (c_fuse_off_t(hsize0)<<32)|c_fuse_off_t(lsize0), fi0))) } func go_hostFgetattr32(path0 *c_char, stat0 *c_fuse_stat_t, fi0 *c_struct_fuse_file_info) (errc0 uintptr) { return uintptr(int(hostFgetattr(path0, stat0, fi0))) } func go_hostUtimens32(path0 *c_char, tmsp0 *c_fuse_timespec_t) (errc0 uintptr) { return uintptr(int(hostUtimens(path0, tmsp0))) } func go_hostSetchgtime32(path0 *c_char, tmsp0 *c_fuse_timespec_t) (errc0 uintptr) { return uintptr(int(hostSetchgtime(path0, tmsp0))) } func go_hostSetcrtime32(path0 *c_char, tmsp0 *c_fuse_timespec_t) (errc0 uintptr) { return uintptr(int(hostSetcrtime(path0, tmsp0))) } func go_hostChflags32(path0 *c_char, flags c_uint32_t) (errc0 uintptr) { return uintptr(int(hostChflags(path0, flags))) }