You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

189 lines
5.2 KiB

3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
  1. package mount
  2. import (
  3. "context"
  4. "fmt"
  5. "github.com/hanwen/go-fuse/v2/fuse"
  6. "github.com/seaweedfs/seaweedfs/weed/filer"
  7. "github.com/seaweedfs/seaweedfs/weed/glog"
  8. "github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
  9. "syscall"
  10. "time"
  11. )
  12. /**
  13. * Flush method
  14. *
  15. * This is called on each close() of the opened file.
  16. *
  17. * Since file descriptors can be duplicated (dup, dup2, fork), for
  18. * one open call there may be many flush calls.
  19. *
  20. * Filesystems shouldn't assume that flush will always be called
  21. * after some writes, or that if will be called at all.
  22. *
  23. * fi->fh will contain the value set by the open method, or will
  24. * be undefined if the open method didn't set any value.
  25. *
  26. * NOTE: the name of the method is misleading, since (unlike
  27. * fsync) the filesystem is not forced to flush pending writes.
  28. * One reason to flush data is if the filesystem wants to return
  29. * write errors during close. However, such use is non-portable
  30. * because POSIX does not require [close] to wait for delayed I/O to
  31. * complete.
  32. *
  33. * If the filesystem supports file locking operations (setlk,
  34. * getlk) it should remove all locks belonging to 'fi->owner'.
  35. *
  36. * If this request is answered with an error code of ENOSYS,
  37. * this is treated as success and future calls to flush() will
  38. * succeed automatically without being send to the filesystem
  39. * process.
  40. *
  41. * Valid replies:
  42. * fuse_reply_err
  43. *
  44. * @param req request handle
  45. * @param ino the inode number
  46. * @param fi file information
  47. *
  48. * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
  49. */
  50. func (wfs *WFS) Flush(cancel <-chan struct{}, in *fuse.FlushIn) fuse.Status {
  51. fh := wfs.GetHandle(FileHandleId(in.Fh))
  52. if fh == nil {
  53. return fuse.ENOENT
  54. }
  55. fh.orderedMutex.Acquire(context.Background(), 1)
  56. defer fh.orderedMutex.Release(1)
  57. return wfs.doFlush(fh, in.Uid, in.Gid)
  58. }
  59. /**
  60. * Synchronize file contents
  61. *
  62. * If the datasync parameter is non-zero, then only the user data
  63. * should be flushed, not the meta data.
  64. *
  65. * If this request is answered with an error code of ENOSYS,
  66. * this is treated as success and future calls to fsync() will
  67. * succeed automatically without being send to the filesystem
  68. * process.
  69. *
  70. * Valid replies:
  71. * fuse_reply_err
  72. *
  73. * @param req request handle
  74. * @param ino the inode number
  75. * @param datasync flag indicating if only data should be flushed
  76. * @param fi file information
  77. */
  78. func (wfs *WFS) Fsync(cancel <-chan struct{}, in *fuse.FsyncIn) (code fuse.Status) {
  79. fh := wfs.GetHandle(FileHandleId(in.Fh))
  80. if fh == nil {
  81. return fuse.ENOENT
  82. }
  83. fh.orderedMutex.Acquire(context.Background(), 1)
  84. defer fh.orderedMutex.Release(1)
  85. return wfs.doFlush(fh, in.Uid, in.Gid)
  86. }
  87. func (wfs *WFS) doFlush(fh *FileHandle, uid, gid uint32) fuse.Status {
  88. // flush works at fh level
  89. fileFullPath := fh.FullPath()
  90. dir, name := fileFullPath.DirAndName()
  91. // send the data to the OS
  92. glog.V(4).Infof("doFlush %s fh %d", fileFullPath, fh.handle)
  93. if !wfs.IsOverQuota {
  94. if err := fh.dirtyPages.FlushData(); err != nil {
  95. glog.Errorf("%v doFlush: %v", fileFullPath, err)
  96. return fuse.EIO
  97. }
  98. }
  99. if !fh.dirtyMetadata {
  100. return fuse.OK
  101. }
  102. if wfs.IsOverQuota {
  103. return fuse.Status(syscall.ENOSPC)
  104. }
  105. err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
  106. fh.entryLock.Lock()
  107. defer fh.entryLock.Unlock()
  108. entry := fh.entry
  109. if entry == nil {
  110. return nil
  111. }
  112. entry.Name = name // this flush may be just after a rename operation
  113. if entry.Attributes != nil {
  114. entry.Attributes.Mime = fh.contentType
  115. if entry.Attributes.Uid == 0 {
  116. entry.Attributes.Uid = uid
  117. }
  118. if entry.Attributes.Gid == 0 {
  119. entry.Attributes.Gid = gid
  120. }
  121. if entry.Attributes.Crtime == 0 {
  122. entry.Attributes.Crtime = time.Now().Unix()
  123. }
  124. entry.Attributes.Mtime = time.Now().Unix()
  125. }
  126. request := &filer_pb.CreateEntryRequest{
  127. Directory: string(dir),
  128. Entry: entry,
  129. Signatures: []int32{wfs.signature},
  130. SkipCheckParentDirectory: true,
  131. }
  132. glog.V(4).Infof("%s set chunks: %v", fileFullPath, len(entry.GetChunks()))
  133. for i, chunk := range entry.GetChunks() {
  134. glog.V(4).Infof("%s chunks %d: %v [%d,%d)", fileFullPath, i, chunk.GetFileIdString(), chunk.Offset, chunk.Offset+int64(chunk.Size))
  135. }
  136. manifestChunks, nonManifestChunks := filer.SeparateManifestChunks(entry.GetChunks())
  137. chunks, _ := filer.CompactFileChunks(wfs.LookupFn(), nonManifestChunks)
  138. chunks, manifestErr := filer.MaybeManifestize(wfs.saveDataAsChunk(fileFullPath), chunks)
  139. if manifestErr != nil {
  140. // not good, but should be ok
  141. glog.V(0).Infof("MaybeManifestize: %v", manifestErr)
  142. }
  143. entry.Chunks = append(chunks, manifestChunks...)
  144. wfs.mapPbIdFromLocalToFiler(request.Entry)
  145. defer wfs.mapPbIdFromFilerToLocal(request.Entry)
  146. if err := filer_pb.CreateEntry(client, request); err != nil {
  147. glog.Errorf("fh flush create %s: %v", fileFullPath, err)
  148. return fmt.Errorf("fh flush create %s: %v", fileFullPath, err)
  149. }
  150. wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry))
  151. return nil
  152. })
  153. if err == nil {
  154. fh.dirtyMetadata = false
  155. }
  156. if err != nil {
  157. glog.Errorf("%v fh %d flush: %v", fileFullPath, fh.handle, err)
  158. return fuse.EIO
  159. }
  160. return fuse.OK
  161. }