seaweedfs/weed/mount/weedfs_file_write.go

package mount

import (
	"net/http"
	"syscall"
	"time"

	"github.com/seaweedfs/go-fuse/v2/fuse"
	"github.com/seaweedfs/seaweedfs/weed/glog"
	"github.com/seaweedfs/seaweedfs/weed/util"
)

// isAppendWrite honors current F_SETFL flags; adapters without flags use the open.
func (wfs *WFS) isAppendWrite(in *fuse.WriteIn) bool {
	if in.Flags != 0 {
		return in.Flags&syscall.O_APPEND != 0
	}
	return wfs.fhMap.isAppendHandle(FileHandleId(in.Fh))
}

/**
 * Write data
 *
 * Write should return exactly the number of bytes requested
 * except on error.  An exception to this is when the file has
 * been opened in 'direct_io' mode, in which case the return value
 * of the write system call will reflect the return value of this
 * operation.
 *
 * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
 * expected to reset the setuid and setgid bits.
 *
 * fi->fh will contain the value set by the open method, or will
 * be undefined if the open method didn't set any value.
 *
 * Valid replies:
 *   fuse_reply_write
 *   fuse_reply_err
 *
 * @param req request handle
 * @param ino the inode number
 * @param buf data to write
 * @param size number of bytes to write
 * @param off offset to write to
 * @param fi file information
 */
func (wfs *WFS) Write(cancel <-chan struct{}, in *fuse.WriteIn, data []byte) (written uint32, code fuse.Status) {

	// Check quota including uncommitted writes for real-time enforcement
	if wfs.IsOverQuotaWithUncommitted() {
		return 0, fuse.Status(syscall.ENOSPC)
	}

	fh := wfs.GetHandle(FileHandleId(in.Fh))
	if fh == nil {
		return 0, fuse.ENOENT
	}

	fh.dirtyPages.writerPattern.MonitorWriteAt(int64(in.Offset), int(in.Size))

	tsNs := time.Now().UnixNano()

	fhActiveLock := fh.wfs.fhLockTable.AcquireLock("Write", fh.fh, util.ExclusiveLock)
	defer fh.wfs.fhLockTable.ReleaseLock(fh.fh, fhActiveLock)

	entry := fh.GetEntry()
	if entry == nil {
		return 0, fuse.OK
	}

	// Size and times cover only the bytes buffered, or the next flush
	// publishes a hole where the data should be. A partly buffered write
	// is reported as a short write, or as an error to kernel writeback,
	// which ignores the count.
	offset := int64(in.Offset)
	buffered, err := fh.dirtyPages.AddPage(offset, data, fh.dirtyPages.writerPattern.IsSequentialMode(), tsNs)
	if err != nil {
		glog.Errorf("AddPage error: %v", err)
		if buffered == 0 {
			return 0, writeErrorToFuseStatus(err)
		}
		data = data[:buffered]
	}
	fh.pageWrites.Add(1)

	// Only an append past all locally owned bytes needs the stored EOF guard.
	if in.Offset > entry.Attributes.FileSize && wfs.isAppendWrite(in) {
		if !fh.pendingAppend || in.Offset < fh.pendingAppendOffset {
			fh.pendingAppendOffset = in.Offset
		}
		fh.pendingAppend = true
	}
	entry.Content = nil
	oldFileSize := int64(entry.Attributes.FileSize)
	newFileSize := max(offset+int64(len(data)), oldFileSize)
	entry.Attributes.FileSize = uint64(newFileSize)

	// POSIX: writes update mtime and ctime. Stamp the entry now so the
	// flush path persists the write time rather than overwriting any
	// user-set mtime (e.g., utimes/touch -m -d) at flush time.
	writeNow := time.Unix(0, tsNs)
	entry.Attributes.Mtime = writeNow.Unix()
	entry.Attributes.MtimeNs = int32(writeNow.Nanosecond())
	entry.Attributes.Ctime = writeNow.Unix()
	entry.Attributes.CtimeNs = int32(writeNow.Nanosecond())

	// Track uncommitted bytes for real-time quota enforcement.
	// Only count the new bytes being added beyond the current file size.
	if newFileSize > oldFileSize {
		wfs.AddUncommittedBytes(newFileSize - oldFileSize)
	}

	written = uint32(len(data))

	if offset == 0 {
		// detect mime type
		fh.contentType = http.DetectContentType(data)
	}

	fh.dirtyMetadata = true
	fh.dirtyContent = true

	// Invalidate the mtime cache so the next Open will not set FOPEN_KEEP_CACHE.
	wfs.invalidateOpenMtimeCache(in.NodeId)

	// POSIX: clear SUID/SGID bits on write by non-root users.
	if in.Uid != 0 {
		entry.Attributes.FileMode &^= 0o6000
	}

	if IsDebugFileReadWrite {
		// print("+")
		fh.mirrorFile.WriteAt(data, offset)
	}

	if err != nil && in.WriteFlags&fuse.WRITE_CACHE != 0 {
		return 0, writeErrorToFuseStatus(err)
	}
	return written, fuse.OK
}