remove redundant contentEnc reference from file

3 files changed, 25 insertions, 28 deletions

diff --git a/internal/fusefrontend/file.go b/internal/fusefrontend/file.go
index 103c217..bb9e539 100644
--- a/internal/fusefrontend/file.go
+++ b/internal/fusefrontend/file.go
@@ -37,8 +37,6 @@ type File struct {
 	// Every FUSE entrypoint should RLock(). The only user of Lock() is
 	// Release(), which closes the fd and sets "released" to true.
 	fdLock sync.RWMutex
-	// Content encryption helper
-	contentEnc *contentenc.ContentEnc
 	// Device and inode number uniquely identify the backing file
 	qIno inomap.QIno
 	// Entry in the open file table
@@ -73,7 +71,6 @@ func NewFile(fd int, cName string, rn *RootNode) (f *File, st *syscall.Stat_t, e
 
 	f = &File{
 		fd:             osFile,
-		contentEnc:     rn.contentEnc,
 		qIno:           qi,
 		fileTableEntry: e,
 		rootNode:       rn,
@@ -177,7 +174,7 @@ func (f *File) doRead(dst []byte, off uint64, length uint64) ([]byte, syscall.Er
 		log.Panicf("fileID=%v", fileID)
 	}
 	// Read the backing ciphertext in one go
-	blocks := f.contentEnc.ExplodePlainRange(off, length)
+	blocks := f.rootNode.contentEnc.ExplodePlainRange(off, length)
 	alignedOffset, alignedLength := blocks[0].JointCiphertextRange(blocks)
 	// f.fd.ReadAt takes an int64!
 	if alignedOffset > math.MaxInt64 {
@@ -206,10 +203,10 @@ func (f *File) doRead(dst []byte, off uint64, length uint64) ([]byte, syscall.Er
 	tlog.Debug.Printf("ReadAt offset=%d bytes (%d blocks), want=%d, got=%d", alignedOffset, firstBlockNo, alignedLength, n)
 
 	// Decrypt it
-	plaintext, err := f.contentEnc.DecryptBlocks(ciphertext, firstBlockNo, fileID)
+	plaintext, err := f.rootNode.contentEnc.DecryptBlocks(ciphertext, firstBlockNo, fileID)
 	f.rootNode.contentEnc.CReqPool.Put(ciphertext)
 	if err != nil {
-		corruptBlockNo := firstBlockNo + f.contentEnc.PlainOffToBlockNo(uint64(len(plaintext)))
+		corruptBlockNo := firstBlockNo + f.rootNode.contentEnc.PlainOffToBlockNo(uint64(len(plaintext)))
 		tlog.Warn.Printf("doRead %d: corrupt block #%d: %v", f.qIno.Ino, corruptBlockNo, err)
 		return nil, syscall.EIO
 	}
@@ -287,20 +284,20 @@ func (f *File) doWrite(data []byte, off int64) (uint32, syscall.Errno) {
 	}
 	// Handle payload data
 	dataBuf := bytes.NewBuffer(data)
-	blocks := f.contentEnc.ExplodePlainRange(uint64(off), uint64(len(data)))
+	blocks := f.rootNode.contentEnc.ExplodePlainRange(uint64(off), uint64(len(data)))
 	toEncrypt := make([][]byte, len(blocks))
 	for i, b := range blocks {
 		blockData := dataBuf.Next(int(b.Length))
 		// Incomplete block -> Read-Modify-Write
 		if b.IsPartial() {
 			// Read
-			oldData, errno := f.doRead(nil, b.BlockPlainOff(), f.contentEnc.PlainBS())
+			oldData, errno := f.doRead(nil, b.BlockPlainOff(), f.rootNode.contentEnc.PlainBS())
 			if errno != 0 {
 				tlog.Warn.Printf("ino%d fh%d: RMW read failed: errno=%d", f.qIno.Ino, f.intFd(), errno)
 				return 0, errno
 			}
 			// Modify
-			blockData = f.contentEnc.MergeBlocks(oldData, blockData, int(b.Skip))
+			blockData = f.rootNode.contentEnc.MergeBlocks(oldData, blockData, int(b.Skip))
 			tlog.Debug.Printf("len(oldData)=%d len(blockData)=%d", len(oldData), len(blockData))
 		}
 		tlog.Debug.Printf("ino%d: Writing %d bytes to block #%d",
@@ -309,7 +306,7 @@ func (f *File) doWrite(data []byte, off int64) (uint32, syscall.Errno) {
 		toEncrypt[i] = blockData
 	}
 	// Encrypt all blocks
-	ciphertext := f.contentEnc.EncryptBlocks(toEncrypt, blocks[0].BlockNo, f.fileTableEntry.ID)
+	ciphertext := f.rootNode.contentEnc.EncryptBlocks(toEncrypt, blocks[0].BlockNo, f.fileTableEntry.ID)
 	// Preallocate so we cannot run out of space in the middle of the write.
 	// This prevents partially written (=corrupt) blocks.
 	var err error
@@ -439,7 +436,7 @@ func (f *File) Getattr(ctx context.Context, a *fuse.AttrOut) syscall.Errno {
 	}
 	f.rootNode.inoMap.TranslateStat(&st)
 	a.FromStat(&st)
-	a.Size = f.contentEnc.CipherSizeToPlainSize(a.Size)
+	a.Size = f.rootNode.contentEnc.CipherSizeToPlainSize(a.Size)
 	if f.rootNode.args.ForceOwner != nil {
 		a.Owner = *f.rootNode.args.ForceOwner
 	}
diff --git a/internal/fusefrontend/file_allocate_truncate.go b/internal/fusefrontend/file_allocate_truncate.go
index cae796e..a3decf9 100644
--- a/internal/fusefrontend/file_allocate_truncate.go
+++ b/internal/fusefrontend/file_allocate_truncate.go
@@ -54,7 +54,7 @@ func (f *File) Allocate(ctx context.Context, off uint64, sz uint64, mode uint32)
 	f.fileTableEntry.ContentLock.Lock()
 	defer f.fileTableEntry.ContentLock.Unlock()
 
-	blocks := f.contentEnc.ExplodePlainRange(off, sz)
+	blocks := f.rootNode.contentEnc.ExplodePlainRange(off, sz)
 	firstBlock := blocks[0]
 	lastBlock := blocks[len(blocks)-1]
 
@@ -63,7 +63,7 @@ func (f *File) Allocate(ctx context.Context, off uint64, sz uint64, mode uint32)
 	// the file.
 	cipherOff := firstBlock.BlockCipherOff()
 	cipherSz := lastBlock.BlockCipherOff() - cipherOff +
-		f.contentEnc.BlockOverhead() + lastBlock.Skip + lastBlock.Length
+		f.rootNode.contentEnc.BlockOverhead() + lastBlock.Skip + lastBlock.Length
 	err := syscallcompat.Fallocate(f.intFd(), FALLOC_FL_KEEP_SIZE, int64(cipherOff), int64(cipherSz))
 	tlog.Debug.Printf("Allocate off=%d sz=%d mode=%x cipherOff=%d cipherSz=%d\n",
 		off, sz, mode, cipherOff, cipherSz)
@@ -113,8 +113,8 @@ func (f *File) truncate(newSize uint64) (errno syscall.Errno) {
 		return fs.ToErrno(err)
 	}
 
-	oldB := float32(oldSize) / float32(f.contentEnc.PlainBS())
-	newB := float32(newSize) / float32(f.contentEnc.PlainBS())
+	oldB := float32(oldSize) / float32(f.rootNode.contentEnc.PlainBS())
+	newB := float32(newSize) / float32(f.rootNode.contentEnc.PlainBS())
 	tlog.Debug.Printf("ino%d: FUSE Truncate from %.2f to %.2f blocks (%d to %d bytes)", f.qIno.Ino, oldB, newB, oldSize, newSize)
 
 	// File size stays the same - nothing to do
@@ -127,9 +127,9 @@ func (f *File) truncate(newSize uint64) (errno syscall.Errno) {
 	}
 
 	// File shrinks
-	blockNo := f.contentEnc.PlainOffToBlockNo(newSize)
-	cipherOff := f.contentEnc.BlockNoToCipherOff(blockNo)
-	plainOff := f.contentEnc.BlockNoToPlainOff(blockNo)
+	blockNo := f.rootNode.contentEnc.PlainOffToBlockNo(newSize)
+	cipherOff := f.rootNode.contentEnc.BlockNoToCipherOff(blockNo)
+	plainOff := f.rootNode.contentEnc.BlockNoToPlainOff(blockNo)
 	lastBlockLen := newSize - plainOff
 	var data []byte
 	if lastBlockLen > 0 {
@@ -161,7 +161,7 @@ func (f *File) statPlainSize() (uint64, error) {
 		return 0, err
 	}
 	cipherSz := uint64(fi.Size())
-	plainSz := uint64(f.contentEnc.CipherSizeToPlainSize(cipherSz))
+	plainSz := uint64(f.rootNode.contentEnc.CipherSizeToPlainSize(cipherSz))
 	return plainSz, nil
 }
 
@@ -174,8 +174,8 @@ func (f *File) truncateGrowFile(oldPlainSz uint64, newPlainSz uint64) syscall.Er
 	}
 	newEOFOffset := newPlainSz - 1
 	if oldPlainSz > 0 {
-		n1 := f.contentEnc.PlainOffToBlockNo(oldPlainSz - 1)
-		n2 := f.contentEnc.PlainOffToBlockNo(newEOFOffset)
+		n1 := f.rootNode.contentEnc.PlainOffToBlockNo(oldPlainSz - 1)
+		n2 := f.rootNode.contentEnc.PlainOffToBlockNo(newEOFOffset)
 		// The file is grown within one block, no need to pad anything.
 		// Write a single zero to the last byte and let doWrite figure out the RMW.
 		if n1 == n2 {
@@ -194,7 +194,7 @@ func (f *File) truncateGrowFile(oldPlainSz uint64, newPlainSz uint64) syscall.Er
 	}
 	// The new size is block-aligned. In this case we can do everything ourselves
 	// and avoid the call to doWrite.
-	if newPlainSz%f.contentEnc.PlainBS() == 0 {
+	if newPlainSz%f.rootNode.contentEnc.PlainBS() == 0 {
 		// The file was empty, so it did not have a header. Create one.
 		if oldPlainSz == 0 {
 			id, err := f.createHeader()
@@ -203,7 +203,7 @@ func (f *File) truncateGrowFile(oldPlainSz uint64, newPlainSz uint64) syscall.Er
 			}
 			f.fileTableEntry.ID = id
 		}
-		cSz := int64(f.contentEnc.PlainSizeToCipherSize(newPlainSz))
+		cSz := int64(f.rootNode.contentEnc.PlainSizeToCipherSize(newPlainSz))
 		err := syscall.Ftruncate(f.intFd(), cSz)
 		if err != nil {
 			tlog.Warn.Printf("Truncate: grow Ftruncate returned error: %v", err)
diff --git a/internal/fusefrontend/file_holes.go b/internal/fusefrontend/file_holes.go
index f35fa70..fc58898 100644
--- a/internal/fusefrontend/file_holes.go
+++ b/internal/fusefrontend/file_holes.go
@@ -21,12 +21,12 @@ func (f *File) writePadHole(targetOff int64) syscall.Errno {
 		tlog.Warn.Printf("checkAndPadHole: Fstat failed: %v", err)
 		return fs.ToErrno(err)
 	}
-	plainSize := f.contentEnc.CipherSizeToPlainSize(uint64(fi.Size()))
+	plainSize := f.rootNode.contentEnc.CipherSizeToPlainSize(uint64(fi.Size()))
 	// Appending a single byte to the file (equivalent to writing to
 	// offset=plainSize) would write to "nextBlock".
-	nextBlock := f.contentEnc.PlainOffToBlockNo(plainSize)
+	nextBlock := f.rootNode.contentEnc.PlainOffToBlockNo(plainSize)
 	// targetBlock is the block the user wants to write to.
-	targetBlock := f.contentEnc.PlainOffToBlockNo(uint64(targetOff))
+	targetBlock := f.rootNode.contentEnc.PlainOffToBlockNo(uint64(targetOff))
 	// The write goes into an existing block or (if the last block was full)
 	// starts a new one directly after the last block. Nothing to do.
 	if targetBlock <= nextBlock {
@@ -45,12 +45,12 @@ func (f *File) writePadHole(targetOff int64) syscall.Errno {
 // Zero-pad the file of size plainSize to the next block boundary. This is a no-op
 // if the file is already block-aligned.
 func (f *File) zeroPad(plainSize uint64) syscall.Errno {
-	lastBlockLen := plainSize % f.contentEnc.PlainBS()
+	lastBlockLen := plainSize % f.rootNode.contentEnc.PlainBS()
 	if lastBlockLen == 0 {
 		// Already block-aligned
 		return 0
 	}
-	missing := f.contentEnc.PlainBS() - lastBlockLen
+	missing := f.rootNode.contentEnc.PlainBS() - lastBlockLen
 	pad := make([]byte, missing)
 	tlog.Debug.Printf("zeroPad: Writing %d bytes\n", missing)
 	_, errno := f.doWrite(pad, int64(plainSize))