mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-11-19 02:15:02 +01:00
* mount: move an open file's read view to the chunks a merge wrote When a flush finds that a file's chunks take more than twice its size, maybeMergeChunks reads the file back and writes it again as new chunks. The commit that publishes them makes the filer delete the chunks they replaced. The flush put the new chunks into the handle's entry but left its read view on the old ones, so every descriptor that kept the file open went on reading the replaced chunks. Those read back until their volume is vacuumed. After that a read first retries the fetch of the missing needle for about 13 s; then refreshEntryForRead installs the filer's entry and the read is retried. The refresh skips a handle with writes it has not flushed, and such a read returns EIO instead. Files that are kept open and rewritten in place, such as PostgreSQL data files and SQLite databases, are the ones whose chunks bloat, so they are the ones that hit this. installRewrittenChunks puts the merge's chunks into the entry and the read view together, under the entry lock. Chunks attached while the merge ran were not part of it and stay. Flushes without a merge are unchanged. TestMergeMovesReadViewOffReplacedChunks covers the handle. TestReadOpenHandleAfterChunkMerge runs it on a real mount, with and without an unflushed write; for it, the fuse_integration framework starts mini on a free master port and exposes the address. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: drain uploads before a merge replaces the chunks Uploads attach their chunks without the handle lock, first to the entry and then to the read view, and writes that landed after doFlush drained the pages may still be uploading when the flush takes its lock. An upload that attached during the merge could keep a chunk older than data the merge already holds, or put a chunk the merge replaced back into the read view. Either outranks the merge's zero-timestamp chunk. When the chunks are bloated enough to merge, the flush now drains the pages again while its lock holds writes off, and takes the chunks again. FlushAll returns only after every upload has attached to both the entry and the read view, so nothing attaches during the merge. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: leave a pre-merge upload failure to the next flush The drain before a merge returned an upload failure through the metadata flush. doFlush then retried it as a filer error and answered EIO, where the page flush answers a full disk with ENOSPC. The drain is there only to wait for the uploads: a failure stays with the pages, and the next flush reports it as a write error, as it would without a merge. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: keep chunks attached while a flush installs its compacted list A write that lands after doFlush drained the pages can still be uploading when flushMetadataToFiler takes its chunk snapshot. Its upload attaches the chunk without the handle lock, and the plain flush then replaced the entry's chunks with the list compacted from the snapshot, dropping it from the handle and from every later commit. Keep chunks attached after the snapshot, as the merge path already does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: fail a merge's flush on a failed drain A failed upload found by the drain before a merge was only logged, and the flush went on to publish a size covering bytes that no chunk stores. It now fails the flush as a pageUploadError before anything is published; doFlush maps it with writeErrorToFuseStatus, as it does its own FlushData failure, and does not retry it as a filer error. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: clone a flush's request entry under the entry lock The request snapshot cloned the live entry after GetEntry had released its read lock. Uploads attach chunks without the handle lock, so an AppendChunks that landed during the clone raced it on the Chunks field. Clone inside UpdateEntry, as content flush recovery does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: leave a merge to a later flush while uploads are pending Before a merge the flush drained the pages while it held the handle and publication locks. A writeback upload retries a transient storage error until it succeeds, so that drain could hold both locks for as long as storage stayed down, stalling reads, writes and stat on the handle. The flush now checks for pending uploads and, if any, publishes the compacted chunks and leaves the merge to a later flush. With none pending the lock still holds writes off, so nothing attaches during the merge, and a failed upload still fails the flush as a write error. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: keep room for pending uploads when a flush merges onto a moved entry A flush that leaves the chunk merge to a later flush publishes while uploads are still pending, and writes that landed after the drain can be uploading on any flush. Merging a peer's inline content or a shrink into such a publication lets the upload attach its chunk next to the inline bytes, where reads never reach it. Tell createContentEntry when uploads are pending so the merge keeps room for them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: test chunk merges through the filer's chunk proxy, also under load The tests serve the filer's chunk proxy, and like the filer the fake deletes the chunks each commit replaces, so a read view still naming them fails: - TestFlushMergeThroughChunkProxy/Quiet: the flush merges, and reads through the open handle return the file from the merged chunk alone. - TestFlushMergeThroughChunkProxy/UploadInFlight: an older page is still uploading while a newer page of the same bytes has attached. The flush leaves the merge, reads return the newer page, and the next flush merges. - TestFlushMergeRacesWithWritesAndReads: four writers, three flushers and a reader on one handle, with uploads delayed at random. The writers pause now and then, so 14 to 18 flushes a run merge and the others leave the merge to a later one. Every read must succeed within 2 s, and at the end the handle and the filer must both hold exactly what was written. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: let a held upload go when UploadInFlight fails The subtest's proxy holds the older page's upload until the test releases it, and only the passing path did. A failure in between left the handler blocked, so the proxy's cleanup waited on it and the failure surfaced as a suite timeout. Release it from a cleanup as well, once, and bound the waits for the upload and the drains. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Chris Lu <chrislusf@users.noreply.github.com>
435 lines
15 KiB
Go
435 lines
15 KiB
Go
package mount
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
"github.com/seaweedfs/go-fuse/v2/fuse"
|
|
"github.com/seaweedfs/seaweedfs/weed/cluster"
|
|
"github.com/seaweedfs/seaweedfs/weed/filer"
|
|
"github.com/seaweedfs/seaweedfs/weed/glog"
|
|
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
|
|
"github.com/seaweedfs/seaweedfs/weed/util"
|
|
)
|
|
|
|
type FileHandleId uint64
|
|
|
|
var IsDebugFileReadWrite = false
|
|
|
|
type FileHandle struct {
|
|
fh FileHandleId
|
|
counter int64
|
|
fhs map[FileHandleId]bool // live fh values, one per open; guarded by fhMap's lock
|
|
entry *LockedEntry
|
|
// Nested handle lock order: wfs.fhLockTable[fh.fh] -> entryLock ->
|
|
// LockedEntry.RWMutex. Paths may use a subset, but must never acquire an
|
|
// earlier lock while holding a later one. Release in reverse order.
|
|
entryLock sync.RWMutex
|
|
entryChunkGroup *filer.ChunkGroup
|
|
inode uint64
|
|
wfs *WFS
|
|
|
|
// cache file has been written to
|
|
pendingAppend bool
|
|
pendingAppendOffset uint64
|
|
writebackContentError *atomic.Bool
|
|
dirtyMetadata bool
|
|
dirtyContent bool
|
|
dirtyPages *PageWriter
|
|
reader *filer.ChunkReadAt
|
|
contentType string
|
|
asyncFlushPending bool // set in writebackCache mode to defer flush to Release
|
|
asyncFlushUid uint32 // saved uid for deferred metadata flush
|
|
asyncFlushGid uint32 // saved gid for deferred metadata flush
|
|
savedDir string // last known parent path if inode-to-path state is forgotten
|
|
savedName string // last known file name if inode-to-path state is forgotten
|
|
|
|
isDeleted bool
|
|
// deleteEpoch counts the times isDeleted was raised, all of them under the
|
|
// handle's flush lock. A caller that raised it and then found it had
|
|
// nothing to delete after all can tell its own mark from a later one.
|
|
deleteEpoch uint64
|
|
isRenamed bool // set by Rename before waiting for async flush; skips old-path metadata flush
|
|
// linkRefresh is the hard link id of a link change whose stored entry
|
|
// could not be read; the next flush reads it before publishing.
|
|
linkRefresh []byte
|
|
|
|
// pageWrites counts the pages added to dirtyPages, under the handle lock.
|
|
pageWrites atomic.Uint64
|
|
|
|
// entryVersionTsNs is the filer log position the handle's entry reflects.
|
|
// State at or below it must not replace the entry — that rolls it back.
|
|
entryVersionTsNs atomic.Int64
|
|
|
|
// entryVersionSignature identifies the filer whose clock stamped
|
|
// entryVersionTsNs, when it came from an RPC fence. Positions from a
|
|
// different filer are not comparable, so an event that filer did not log
|
|
// is applied rather than fenced out. Zero when the version came from an
|
|
// event, whose ordering the subscription already provides.
|
|
entryVersionSignature atomic.Int32
|
|
|
|
// baseEntry snapshots the filer state last installed or acknowledged.
|
|
// Local writes move the live entry away from it, so "is this event new"
|
|
// must be judged here, not against the live entry. Always store a clone.
|
|
baseEntry atomic.Pointer[filer_pb.Entry]
|
|
|
|
// sinceBase marks a truncate or chunk rewrite over baseEntry that a
|
|
// merge must honor: later writes can grow the file past a truncate, and
|
|
// rewritten chunks carry the handle's view of the base.
|
|
sinceBase atomic.Pointer[baseMark]
|
|
|
|
// chunkViewStale marks a read view whose manifest resolution failed; the
|
|
// next read or lseek resolves the entry's chunks again.
|
|
chunkViewStale atomic.Bool
|
|
|
|
// dlmLock holds the distributed lock for cross-mount write coordination.
|
|
// Non-nil only when -dlm is enabled and the file was opened for writing.
|
|
// Acquired in AcquireHandle, released in ReleaseHandle.
|
|
dlmLock *cluster.LiveLock
|
|
|
|
// remoteInstallMu serializes downloadRemoteEntry's install, which holds
|
|
// only the handle's shared lock and so races a second concurrent read.
|
|
remoteInstallMu sync.Mutex
|
|
|
|
// for debugging
|
|
mirrorFile *os.File
|
|
}
|
|
|
|
func newFileHandle(wfs *WFS, handleId FileHandleId, inode uint64, entry *filer_pb.Entry) *FileHandle {
|
|
fh := &FileHandle{
|
|
fh: handleId,
|
|
counter: 1,
|
|
fhs: map[FileHandleId]bool{handleId: false},
|
|
inode: inode,
|
|
wfs: wfs,
|
|
}
|
|
// dirtyPages: newContinuousDirtyPages(file, writeOnly),
|
|
fh.dirtyPages = newPageWriter(fh, wfs.option.ChunkSizeLimit)
|
|
fh.entry = &LockedEntry{
|
|
Entry: entry,
|
|
}
|
|
if entry != nil {
|
|
fh.SetEntry(entry)
|
|
fh.baseEntry.Store(proto.Clone(entry).(*filer_pb.Entry))
|
|
}
|
|
|
|
if IsDebugFileReadWrite {
|
|
var err error
|
|
fh.mirrorFile, err = os.OpenFile("/tmp/sw/"+entry.Name, os.O_RDWR|os.O_CREATE, 0600)
|
|
if err != nil {
|
|
println("failed to create mirror:", err.Error())
|
|
}
|
|
}
|
|
|
|
return fh
|
|
}
|
|
|
|
func (fh *FileHandle) FullPath() util.FullPath {
|
|
if fp, status := fh.wfs.inodeToPath.GetPath(fh.inode); status == fuse.OK {
|
|
return fp
|
|
}
|
|
if fh.savedName != "" {
|
|
return util.FullPath(fh.savedDir).Child(fh.savedName)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (fh *FileHandle) RememberPath(fullPath util.FullPath) {
|
|
if fullPath == "" {
|
|
return
|
|
}
|
|
fh.savedDir, fh.savedName = fullPath.DirAndName()
|
|
}
|
|
|
|
func (fh *FileHandle) GetEntry() *LockedEntry {
|
|
return fh.entry
|
|
}
|
|
|
|
// entrySnapshot copies the handle's entry under the locks of both of its
|
|
// writers, as GetAttr reads it: Write and the metadata flush change size,
|
|
// times and chunks under the handle lock, while async upload workers append
|
|
// chunks under the LockedEntry lock.
|
|
func (fh *FileHandle) entrySnapshot(dir string) *filer.Entry {
|
|
fhActiveLock := fh.wfs.fhLockTable.AcquireLock("entrySnapshot", fh.fh, util.SharedLock)
|
|
defer fh.wfs.fhLockTable.ReleaseLock(fh.fh, fhActiveLock)
|
|
fh.entry.RLock()
|
|
var snapshot *filer_pb.Entry
|
|
if fh.entry.Entry != nil {
|
|
snapshot = proto.Clone(fh.entry.Entry).(*filer_pb.Entry)
|
|
}
|
|
fh.entry.RUnlock()
|
|
if snapshot == nil {
|
|
return nil
|
|
}
|
|
return filer.FromPbEntry(dir, snapshot)
|
|
}
|
|
|
|
func (fh *FileHandle) SetEntry(entry *filer_pb.Entry) {
|
|
if entry != nil {
|
|
fileSize := filer.FileSize(entry)
|
|
entry.Attributes.FileSize = fileSize
|
|
if fh.entryChunkGroup != nil {
|
|
_ = fh.entryChunkGroup.Close()
|
|
}
|
|
var resolveManifestErr error
|
|
fh.entryChunkGroup, resolveManifestErr = filer.NewChunkGroup(fh.wfs.LookupFn(), fh.wfs.chunkCache, entry.Chunks, fh.wfs.option.ConcurrentReaders, fh.wfs.CacheInvalidator(), fh.wfs.manifestCache, fh.wfs.readerCacheBudget)
|
|
if resolveManifestErr != nil {
|
|
glog.Warningf("failed to resolve manifest chunks in %+v", filer_pb.ScrubCipherKeys(entry))
|
|
}
|
|
fh.chunkViewStale.Store(resolveManifestErr != nil)
|
|
} else {
|
|
glog.Fatalf("setting file handle entry to nil")
|
|
}
|
|
fh.entry.SetEntry(entry)
|
|
}
|
|
|
|
// installAckedEntry installs filer-acknowledged state under the handle lock
|
|
// when it outranks the handle. A version never advances without its value:
|
|
// stamping alone would fence out the events carrying what the handle lacks.
|
|
// Dirty handles are skipped — local writes supersede the ack. Deleted ones
|
|
// too: their path may already name a different file, and no acknowledged
|
|
// state belongs to this handle anymore.
|
|
func (fh *FileHandle) installAckedEntry(entry *filer_pb.Entry, versionTsNs int64, signature int32) {
|
|
fhActiveLock := fh.wfs.fhLockTable.AcquireLock("installAckedEntry", fh.fh, util.ExclusiveLock)
|
|
defer fh.wfs.fhLockTable.ReleaseLock(fh.fh, fhActiveLock)
|
|
if versionTsNs == 0 || fh.dirtyMetadata || fh.isDeleted || entry == fh.GetEntry().GetEntry() {
|
|
return
|
|
}
|
|
// Refuse only what is provably older. Two known, differing filer
|
|
// signatures mean the positions come from unrelated clocks and say
|
|
// nothing about each other; dropping the acknowledgment there would leave
|
|
// the handle holding the very state this mutation replaced. Unknown
|
|
// signatures still compare, as they did before.
|
|
handleSignature := fh.entryVersionSignature.Load()
|
|
provablyOtherClock := signature != 0 && handleSignature != 0 && signature != handleSignature
|
|
if !provablyOtherClock && versionTsNs <= fh.entryVersionTsNs.Load() {
|
|
return
|
|
}
|
|
fh.SetEntry(entry)
|
|
fh.setAuthoritativeBase(proto.Clone(entry).(*filer_pb.Entry))
|
|
fh.advanceEntryVersion(versionTsNs, signature)
|
|
}
|
|
|
|
// rebaseEntry installs an entry merged with a peer's changes, keeping the
|
|
// chunks and growth writers added after sent was taken, and refreshes the
|
|
// read view.
|
|
func (fh *FileHandle) rebaseEntry(merged, sent *filer_pb.Entry) {
|
|
inSent := make(map[string]bool, len(sent.Chunks))
|
|
for _, c := range sent.Chunks {
|
|
inSent[contentChunkKey(c)] = true
|
|
}
|
|
merged = proto.Clone(merged).(*filer_pb.Entry)
|
|
fh.UpdateEntry(func(e *filer_pb.Entry) {
|
|
chunks := merged.Chunks
|
|
for _, c := range e.Chunks {
|
|
if !inSent[contentChunkKey(c)] {
|
|
chunks = append(chunks, c)
|
|
}
|
|
}
|
|
attrs := merged.Attributes
|
|
if size := e.GetAttributes().GetFileSize(); size > sent.GetAttributes().GetFileSize() && size > attrs.FileSize {
|
|
attrs.FileSize = size
|
|
}
|
|
e.Attributes, e.Extended, e.Content, e.Chunks = attrs, merged.Extended, merged.Content, chunks
|
|
err := fh.entryChunkGroup.SetChunks(chunks)
|
|
if err != nil {
|
|
glog.Warningf("rebase %s: resolve chunks: %v", fh.FullPath(), err)
|
|
}
|
|
fh.chunkViewStale.Store(err != nil)
|
|
})
|
|
}
|
|
|
|
// installRewrittenChunks replaces the chunks a merge rewrote, taken from
|
|
// snapshot, with rewritten, and moves the read view to the result: the filer
|
|
// deletes the replaced chunks once the merge is committed, and a view still
|
|
// naming them would send reads to needles a vacuum removes. Chunks attached
|
|
// after snapshot was taken were not part of the merge and stay.
|
|
func (fh *FileHandle) installRewrittenChunks(snapshot, rewritten []*filer_pb.FileChunk) {
|
|
fh.UpdateEntry(func(e *filer_pb.Entry) {
|
|
chunks := withChunksAttachedSince(snapshot, rewritten, e.Chunks)
|
|
e.Chunks = chunks
|
|
err := fh.entryChunkGroup.SetChunks(chunks)
|
|
if err != nil {
|
|
glog.Warningf("merge %s: resolve chunks: %v", fh.FullPath(), err)
|
|
}
|
|
fh.chunkViewStale.Store(err != nil)
|
|
})
|
|
}
|
|
|
|
// withChunksAttachedSince returns processed, the chunks a flush made from
|
|
// snapshot, followed by the chunks uploads attached to current after snapshot
|
|
// was taken: they attach without the handle lock.
|
|
func withChunksAttachedSince(snapshot, processed, current []*filer_pb.FileChunk) []*filer_pb.FileChunk {
|
|
inSnapshot := make(map[string]bool, len(snapshot))
|
|
for _, c := range snapshot {
|
|
inSnapshot[contentFileIdKey(c)] = true
|
|
}
|
|
chunks := append([]*filer_pb.FileChunk{}, processed...)
|
|
for _, c := range current {
|
|
if !inSnapshot[contentFileIdKey(c)] {
|
|
chunks = append(chunks, c)
|
|
}
|
|
}
|
|
return chunks
|
|
}
|
|
|
|
// refreshChunkView retries a read view whose manifest resolution failed.
|
|
func (fh *FileHandle) refreshChunkView() {
|
|
if !fh.chunkViewStale.Load() {
|
|
return
|
|
}
|
|
fh.UpdateEntry(func(e *filer_pb.Entry) {
|
|
fh.chunkViewStale.Store(fh.entryChunkGroup.SetChunks(e.Chunks) != nil)
|
|
})
|
|
}
|
|
|
|
// mergePeerContent folds a peer's change into a dirty handle, so its own
|
|
// writes stay on top of the peer's instead of being discarded.
|
|
func (fh *FileHandle) mergePeerContent(peer, base *filer_pb.Entry) bool {
|
|
var local *filer_pb.Entry
|
|
fh.UpdateEntry(func(e *filer_pb.Entry) {
|
|
local = proto.Clone(e).(*filer_pb.Entry)
|
|
})
|
|
mark := fh.markSince(base)
|
|
merged, ok := mergeContentEntry(peer, base, local, local, mark.truncatedTo, mark.rewrote)
|
|
ok = ok && mergeKeepsBuffered(merged, local)
|
|
if ok {
|
|
fh.rebaseEntry(merged, local)
|
|
}
|
|
return ok
|
|
}
|
|
|
|
// mergeKeepsBuffered reports whether merged leaves room for writes still
|
|
// buffered over local. They are not chunks yet, so a merge that shrinks the
|
|
// file or brings in inline content (read ahead of chunks) waits for the flush.
|
|
func mergeKeepsBuffered(merged, local *filer_pb.Entry) bool {
|
|
return merged.Attributes.FileSize >= filer.FileSize(local) && bytes.Equal(merged.Content, local.Content)
|
|
}
|
|
|
|
// baseMark records what the handle did over base that its entry does not
|
|
// show: the lowest size a truncate set (-1 for none), and a whole-file
|
|
// rewrite of its chunks.
|
|
type baseMark struct {
|
|
base *filer_pb.Entry
|
|
truncatedTo int64
|
|
rewrote bool
|
|
}
|
|
|
|
func (fh *FileHandle) markBase(update func(m *baseMark)) {
|
|
for {
|
|
base, old := fh.baseEntry.Load(), fh.sinceBase.Load()
|
|
next := baseMark{base: base, truncatedTo: -1}
|
|
if old != nil && old.base == base {
|
|
next = *old
|
|
}
|
|
update(&next)
|
|
if fh.sinceBase.CompareAndSwap(old, &next) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// noteTruncate records a truncate to size over the current base.
|
|
func (fh *FileHandle) noteTruncate(size uint64) {
|
|
fh.markBase(func(m *baseMark) {
|
|
if m.truncatedTo < 0 || int64(size) < m.truncatedTo {
|
|
m.truncatedTo = int64(size)
|
|
}
|
|
})
|
|
}
|
|
|
|
// noteRewrite records that the handle's chunks were rewritten from its view
|
|
// of the current base.
|
|
func (fh *FileHandle) noteRewrite() {
|
|
fh.markBase(func(m *baseMark) { m.rewrote = true })
|
|
}
|
|
|
|
// adoptPeerBase moves a dirty handle's base to a peer's entry. What the
|
|
// handle has not published yet still applies over the new base.
|
|
func (fh *FileHandle) adoptPeerBase(base *filer_pb.Entry) {
|
|
old := fh.baseEntry.Swap(base)
|
|
if m := fh.sinceBase.Load(); m != nil && m.base == old {
|
|
moved := *m
|
|
moved.base = base
|
|
fh.sinceBase.CompareAndSwap(m, &moved)
|
|
}
|
|
}
|
|
|
|
// markSince is what the handle did over base.
|
|
func (fh *FileHandle) markSince(base *filer_pb.Entry) baseMark {
|
|
if m := fh.sinceBase.Load(); m != nil && m.base == base {
|
|
return *m
|
|
}
|
|
return baseMark{base: base, truncatedTo: -1}
|
|
}
|
|
|
|
// setAuthoritativeBase installs the base snapshot a local ack acknowledged.
|
|
func (fh *FileHandle) setAuthoritativeBase(base *filer_pb.Entry) {
|
|
fh.baseEntry.Store(base)
|
|
}
|
|
|
|
// advanceEntryVersion raises the entry version, never regresses it, and
|
|
// records the clock domain the new position belongs to: a filer signature for
|
|
// an RPC fence, zero for an event. The signature travels with the timestamp so
|
|
// the two never disagree. A zero position (an unversioned old filer) is a
|
|
// no-op, leaving the handle open to refreshes.
|
|
func (fh *FileHandle) advanceEntryVersion(tsNs int64, signature int32) {
|
|
if tsNs == 0 {
|
|
return
|
|
}
|
|
for {
|
|
current := fh.entryVersionTsNs.Load()
|
|
if tsNs <= current {
|
|
return
|
|
}
|
|
if fh.entryVersionTsNs.CompareAndSwap(current, tsNs) {
|
|
fh.entryVersionSignature.Store(signature)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (fh *FileHandle) ResetDirtyPages() {
|
|
fh.dirtyPages.Destroy()
|
|
fh.dirtyPages = newPageWriter(fh, fh.wfs.option.ChunkSizeLimit)
|
|
fh.dirtyMetadata = false
|
|
fh.dirtyContent = false
|
|
fh.pendingAppend = false
|
|
fh.contentType = ""
|
|
}
|
|
|
|
func (fh *FileHandle) UpdateEntry(fn func(entry *filer_pb.Entry)) *filer_pb.Entry {
|
|
result := fh.entry.UpdateEntry(fn)
|
|
|
|
return result
|
|
}
|
|
|
|
func (fh *FileHandle) AddChunks(chunks []*filer_pb.FileChunk) {
|
|
fh.entry.AppendChunks(chunks)
|
|
}
|
|
|
|
func (fh *FileHandle) ReleaseHandle() {
|
|
fhActiveLock := fh.wfs.fhLockTable.AcquireLock("ReleaseHandle", fh.fh, util.ExclusiveLock)
|
|
defer fh.wfs.fhLockTable.ReleaseLock(fh.fh, fhActiveLock)
|
|
|
|
// Release distributed lock before cleaning up, so other mounts can
|
|
// proceed as soon as this handle is done flushing.
|
|
if fh.dlmLock != nil {
|
|
fh.dlmLock.Stop()
|
|
fh.dlmLock = nil
|
|
glog.V(1).Infof("DLM lock released for inode %d", fh.inode)
|
|
}
|
|
|
|
if fh.entryChunkGroup != nil {
|
|
_ = fh.entryChunkGroup.Close()
|
|
}
|
|
fh.dirtyPages.Destroy()
|
|
if IsDebugFileReadWrite {
|
|
fh.mirrorFile.Close()
|
|
}
|
|
}
|