shm_syscall.go 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  1. // License: GPLv3 Copyright: 2022, Kovid Goyal, <kovid at kovidgoyal.net>
  2. //go:build darwin || freebsd
  3. package shm
  4. import (
  5. "errors"
  6. "fmt"
  7. "io"
  8. "io/fs"
  9. "os"
  10. "strings"
  11. "unsafe"
  12. "kitty/tools/utils"
  13. "golang.org/x/sys/unix"
  14. )
  15. var _ = fmt.Print
  16. // ByteSliceFromString makes a zero terminated byte slice from the string
  17. func ByteSliceFromString(s string) []byte {
  18. a := make([]byte, len(s)+1)
  19. copy(a, s)
  20. return a
  21. }
  22. func BytePtrFromString(s string) *byte {
  23. a := ByteSliceFromString(s)
  24. return &a[0]
  25. }
  26. func shm_unlink(name string) (err error) {
  27. bname := BytePtrFromString(name)
  28. for {
  29. _, _, errno := unix.Syscall(unix.SYS_SHM_UNLINK, uintptr(unsafe.Pointer(bname)), 0, 0)
  30. if errno != unix.EINTR {
  31. if errno != 0 {
  32. if errno == unix.ENOENT {
  33. err = fs.ErrNotExist
  34. } else {
  35. err = fmt.Errorf("shm_unlink() failed with error: %w", errno)
  36. }
  37. }
  38. break
  39. }
  40. }
  41. return
  42. }
  43. func ShmUnlink(name string) error {
  44. return shm_unlink(name)
  45. }
  46. func shm_open(name string, flags, perm int) (ans *os.File, err error) {
  47. bname := BytePtrFromString(name)
  48. var fd uintptr
  49. var errno unix.Errno
  50. for {
  51. fd, _, errno = unix.Syscall(unix.SYS_SHM_OPEN, uintptr(unsafe.Pointer(bname)), uintptr(flags), uintptr(perm))
  52. if errno != unix.EINTR {
  53. if errno != 0 {
  54. err = fmt.Errorf("shm_open() failed with error: %w", errno)
  55. }
  56. break
  57. }
  58. }
  59. if err == nil {
  60. ans = os.NewFile(fd, name)
  61. }
  62. return
  63. }
  64. type syscall_based_mmap struct {
  65. f *os.File
  66. pos int64
  67. region []byte
  68. unlinked bool
  69. }
  70. func syscall_mmap(f *os.File, size uint64, access AccessFlags, truncate bool) (MMap, error) {
  71. if truncate {
  72. err := truncate_or_unlink(f, size, shm_unlink)
  73. if err != nil {
  74. return nil, fmt.Errorf("truncate failed with error: %w", err)
  75. }
  76. }
  77. region, err := mmap(int(size), access, int(f.Fd()), 0)
  78. if err != nil {
  79. _ = f.Close()
  80. _ = shm_unlink(f.Name())
  81. return nil, fmt.Errorf("mmap failed with error: %w", err)
  82. }
  83. return &syscall_based_mmap{f: f, region: region}, nil
  84. }
  85. func (self *syscall_based_mmap) Name() string {
  86. return self.f.Name()
  87. }
  88. func (self *syscall_based_mmap) Stat() (fs.FileInfo, error) {
  89. return self.f.Stat()
  90. }
  91. func (self *syscall_based_mmap) Flush() error {
  92. return unix.Msync(self.region, unix.MS_SYNC)
  93. }
  94. func (self *syscall_based_mmap) Slice() []byte {
  95. return self.region
  96. }
  97. func (self *syscall_based_mmap) Close() (err error) {
  98. if self.region != nil {
  99. self.f.Close()
  100. munmap(self.region)
  101. self.region = nil
  102. }
  103. return
  104. }
  105. func (self *syscall_based_mmap) Unlink() (err error) {
  106. if self.unlinked {
  107. return nil
  108. }
  109. self.unlinked = true
  110. return shm_unlink(self.Name())
  111. }
  112. func (self *syscall_based_mmap) Seek(offset int64, whence int) (ret int64, err error) {
  113. switch whence {
  114. case io.SeekStart:
  115. self.pos = offset
  116. case io.SeekEnd:
  117. self.pos = int64(len(self.region)) + offset
  118. case io.SeekCurrent:
  119. self.pos += offset
  120. }
  121. return self.pos, nil
  122. }
  123. func (self *syscall_based_mmap) Read(b []byte) (n int, err error) {
  124. return Read(self, b)
  125. }
  126. func (self *syscall_based_mmap) Write(b []byte) (n int, err error) {
  127. return Write(self, b)
  128. }
  129. func (self *syscall_based_mmap) IsFileSystemBacked() bool { return false }
  130. func (self *syscall_based_mmap) FileSystemName() string { return "" }
  131. func create_temp(pattern string, size uint64) (ans MMap, err error) {
  132. var prefix, suffix string
  133. prefix, suffix, err = prefix_and_suffix(pattern)
  134. if err != nil {
  135. return
  136. }
  137. if SHM_REQUIRED_PREFIX != "" && !strings.HasPrefix(pattern, SHM_REQUIRED_PREFIX) {
  138. // FreeBSD requires name to start with /
  139. prefix = SHM_REQUIRED_PREFIX + prefix
  140. }
  141. var f *os.File
  142. try := 0
  143. for {
  144. name := prefix + utils.RandomFilename() + suffix
  145. if len(name) > SHM_NAME_MAX {
  146. return nil, ErrPatternTooLong
  147. }
  148. f, err = shm_open(name, os.O_EXCL|os.O_CREATE|os.O_RDWR, 0600)
  149. if err != nil && (errors.Is(err, fs.ErrExist) || errors.Unwrap(err) == unix.EEXIST) {
  150. try += 1
  151. if try > 10000 {
  152. return nil, &os.PathError{Op: "createtemp", Path: prefix + "*" + suffix, Err: fs.ErrExist}
  153. }
  154. continue
  155. }
  156. break
  157. }
  158. if err != nil {
  159. return nil, err
  160. }
  161. return syscall_mmap(f, size, WRITE, true)
  162. }
  163. func Open(name string, size uint64) (MMap, error) {
  164. ans, err := shm_open(name, os.O_RDONLY, 0)
  165. if err != nil {
  166. return nil, err
  167. }
  168. if size == 0 {
  169. s, err := ans.Stat()
  170. if err != nil {
  171. ans.Close()
  172. return nil, fmt.Errorf("Failed to stat SHM file with error: %w", err)
  173. }
  174. size = uint64(s.Size())
  175. }
  176. return syscall_mmap(ans, size, READ, false)
  177. }