weedfs_file_lseek.go 2.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111
  1. package mount
  2. import (
  3. "context"
  4. "syscall"
  5. "github.com/hanwen/go-fuse/v2/fuse"
  6. "github.com/seaweedfs/seaweedfs/weed/filer"
  7. "github.com/seaweedfs/seaweedfs/weed/glog"
  8. )
  9. // These are non-POSIX extensions
  10. const (
  11. SEEK_DATA uint32 = 3 // seek to next data after the offset
  12. SEEK_HOLE uint32 = 4 // seek to next hole after the offset
  13. ENXIO = fuse.Status(syscall.ENXIO)
  14. )
  15. // Lseek finds next data or hole segments after the specified offset
  16. // See https://man7.org/linux/man-pages/man2/lseek.2.html
  17. func (wfs *WFS) Lseek(cancel <-chan struct{}, in *fuse.LseekIn, out *fuse.LseekOut) fuse.Status {
  18. // not a documented feature
  19. if in.Padding != 0 {
  20. return fuse.EINVAL
  21. }
  22. if in.Whence != SEEK_DATA && in.Whence != SEEK_HOLE {
  23. return fuse.EINVAL
  24. }
  25. // file must exist
  26. fh := wfs.GetHandle(FileHandleId(in.Fh))
  27. if fh == nil {
  28. return fuse.EBADF
  29. }
  30. // lock the file until the proper offset was calculated
  31. fh.orderedMutex.Acquire(context.Background(), 1)
  32. defer fh.orderedMutex.Release(1)
  33. fh.entryLock.Lock()
  34. defer fh.entryLock.Unlock()
  35. fileSize := int64(filer.FileSize(fh.entry))
  36. offset := max(int64(in.Offset), 0)
  37. glog.V(4).Infof(
  38. "Lseek %s fh %d in [%d,%d], whence %d",
  39. fh.FullPath(), fh.fh, offset, fileSize, in.Whence,
  40. )
  41. // can neither seek beyond file nor seek to a hole at the end of the file with SEEK_DATA
  42. if offset > fileSize {
  43. return ENXIO
  44. } else if in.Whence == SEEK_DATA && offset == fileSize {
  45. return ENXIO
  46. }
  47. // refresh view cache if necessary
  48. if fh.entryViewCache == nil {
  49. var err error
  50. fh.entryViewCache, err = filer.NonOverlappingVisibleIntervals(fh.wfs.LookupFn(), fh.entry.Chunks, 0, fileSize)
  51. if err != nil {
  52. return fuse.EIO
  53. }
  54. }
  55. // search chunks for the offset
  56. found, offset := searchChunks(fh, offset, fileSize, in.Whence)
  57. if found {
  58. out.Offset = uint64(offset)
  59. return fuse.OK
  60. }
  61. // in case we found no exact matches, we return the recommended fallbacks, that is:
  62. // original offset for SEEK_DATA or end of file for an implicit hole
  63. if in.Whence == SEEK_DATA {
  64. out.Offset = in.Offset
  65. } else {
  66. out.Offset = uint64(fileSize)
  67. }
  68. return fuse.OK
  69. }
  70. // searchChunks goes through all chunks to find the correct offset
  71. func searchChunks(fh *FileHandle, offset, fileSize int64, whence uint32) (found bool, out int64) {
  72. chunkViews := filer.ViewFromVisibleIntervals(fh.entryViewCache, offset, fileSize)
  73. for _, chunkView := range chunkViews {
  74. if offset < chunkView.LogicOffset {
  75. if whence == SEEK_HOLE {
  76. out = offset
  77. } else {
  78. out = chunkView.LogicOffset
  79. }
  80. return true, out
  81. }
  82. if offset >= chunkView.LogicOffset && offset < chunkView.Offset+int64(chunkView.Size) && whence == SEEK_DATA {
  83. out = offset
  84. return true, out
  85. }
  86. offset += int64(chunkView.Size)
  87. }
  88. return
  89. }