Hard links Support Phase 1: Gofer Client dentry/inode refactor

This commit does the following:
 - Decouples dentry fields and the file's metadata (inode fields)
 - Embeds the inode pointer into dentry struct {}
 - Removed impl from dentry struct {} and extended inode struct with
back-end implementation
 - Refactor Gofer client fs to access the newly created inode pointer
 - Refactor dentry_impl.go to inode_impl.go
 - Refactor {directfs/lisafs}_dentry to {directfs/lisafs}_inode

PiperOrigin-RevId: 750748327

Author: tranji-cloud

pkg/sentry/fsimpl/gofer/BUILD

@@ -5,6 +5,17 @@ package(default_applicable_licenses = ["//:license"])
 
 licenses(["notice"])
 
+go_template_instance(
+    name = "inode_refs",
+    out = "inode_refs.go",
+    package = "gofer",
+    prefix = "inode",
+    template = "//pkg/refs:refs_template",
+    types = {
+        "T": "inode",
+    },
+)
+
 go_template_instance(
     name = "string_list",
     out = "string_list.go",
@@ -56,16 +67,17 @@ go_template_instance(
 go_library(
     name = "gofer",
     srcs = [
-        "dentry_impl.go",
         "dentry_list.go",
-        "directfs_dentry.go",
+        "directfs_inode.go",
         "directory.go",
         "filesystem.go",
         "fstree.go",
         "gofer.go",
         "handle.go",
         "host_named_pipe.go",
-        "lisafs_dentry.go",
+        "inode_impl.go",
+        "inode_refs.go",
+        "lisafs_inode.go",
         "regular_file.go",
         "revalidate.go",
         "save_restore.go",
@@ -112,6 +124,7 @@ go_library(
         "//pkg/sentry/socket/unix/transport",
         "//pkg/sentry/usage",
         "//pkg/sentry/vfs",
+        "//pkg/sentry/vfs/memxattr",
         "//pkg/sync",
         "//pkg/syserr",
         "//pkg/unet",

pkg/sentry/fsimpl/gofer/directfs_dentry.go renamed to pkg/sentry/fsimpl/gofer/directfs_inode.go

@@ -30,7 +30,7 @@ import (
 )
 
 func (d *dentry) isDir() bool {
-	return d.fileType() == linux.S_IFDIR
+	return d.inode.fileType() == linux.S_IFDIR
 }
 
 // cacheNewChildLocked will cache the new child dentry, and will panic if a
@@ -51,7 +51,7 @@ func (d *dentry) isDir() bool {
 // +checklocks:d.childrenMu
 func (d *dentry) cacheNewChildLocked(child *dentry, name string) {
 	d.IncRef() // reference held by child on its parent
-	genericSetParentAndName(d.fs, child, d, name)
+	genericSetParentAndName(d.inode.fs, child, d, name)
 	if d.children == nil {
 		d.children = make(map[string]*dentry)
 	} else if c, ok := d.children[name]; ok {
@@ -74,10 +74,10 @@ func (d *dentry) cacheNewChildLocked(child *dentry, name string) {
 // +checklocks:d.childrenMu
 func (d *dentry) cacheNegativeLookupLocked(name string) {
 	// Don't cache negative lookups if InteropModeShared is in effect (since
-	// this makes remote lookup unavoidable), or if d.isSynthetic() (in which
+	// this makes remote lookup unavoidable), or if d.inode.isSynthetic() (in which
 	// case the only files in the directory are those for which a dentry exists
 	// in d.children). Instead, just delete any previously-cached dentry.
-	if d.fs.opts.interop == InteropModeShared || d.isSynthetic() {
+	if d.inode.fs.opts.interop == InteropModeShared || d.inode.isSynthetic() {
 		delete(d.children, name)
 		return
 	}
@@ -124,34 +124,41 @@ type createSyntheticOpts struct {
 // newSyntheticDentry creates a synthetic file with the given name.
 func (fs *filesystem) newSyntheticDentry(opts *createSyntheticOpts) *dentry {
 	now := fs.clock.Now().Nanoseconds()
+	ino := fs.nextIno()
+	inodePtr := fs.findInode(ino)
+	if inodePtr == nil {
+		inodePtr = new(inode)
+		inodePtr.init(fs, ino, nil)
+	}
+
 	child := &dentry{
-		refs:      atomicbitops.FromInt64(1), // held by parent.
-		fs:        fs,
-		ino:       fs.nextIno(),
-		mode:      atomicbitops.FromUint32(uint32(opts.mode)),
-		uid:       atomicbitops.FromUint32(uint32(opts.kuid)),
-		gid:       atomicbitops.FromUint32(uint32(opts.kgid)),
-		blockSize: atomicbitops.FromUint32(hostarch.PageSize), // arbitrary
-		atime:     atomicbitops.FromInt64(now),
-		mtime:     atomicbitops.FromInt64(now),
-		ctime:     atomicbitops.FromInt64(now),
-		btime:     atomicbitops.FromInt64(now),
-		readFD:    atomicbitops.FromInt32(-1),
-		writeFD:   atomicbitops.FromInt32(-1),
-		mmapFD:    atomicbitops.FromInt32(-1),
-		nlink:     atomicbitops.FromUint32(2),
+		refs:  atomicbitops.FromInt64(1), // held by parent.
+		inode: inodePtr,
 	}
+
+	child.inode.mode.Store(uint32(opts.mode))
+	child.inode.uid.Store(uint32(opts.kuid))
+	child.inode.gid.Store(uint32(opts.kgid))
+	child.inode.blockSize.Store(hostarch.PageSize)
+	child.inode.atime.Store(now)
+	child.inode.mtime.Store(now)
+	child.inode.ctime.Store(now)
+	child.inode.btime.Store(now)
+	child.inode.nlink.Store(2)
+	child.inode.readFD.Store(-1)
+	child.inode.writeFD.Store(-1)
+	child.inode.mmapFD.Store(-1)
 	switch opts.mode.FileType() {
 	case linux.S_IFDIR:
 		// Nothing else needs to be done.
 	case linux.S_IFSOCK:
-		child.endpoint = opts.endpoint
+		child.inode.endpoint = opts.endpoint
 	case linux.S_IFIFO:
-		child.pipe = opts.pipe
+		child.inode.pipe = opts.pipe
 	default:
 		panic(fmt.Sprintf("failed to create synthetic file of unrecognized type: %v", opts.mode.FileType()))
 	}
-	child.init(nil /* impl */)
+	child.init()
 	return child
 }
 
@@ -192,7 +199,7 @@ func (fd *directoryFD) IterDirents(ctx context.Context, cb vfs.IterDirentsCallba
 		fd.dirents = ds
 	}
 
-	if d.cachedMetadataAuthoritative() {
+	if d.inode.cachedMetadataAuthoritative() {
 		d.touchAtime(fd.vfsfd.Mount())
 	}
 
@@ -224,8 +231,8 @@ func (d *dentry) getDirents(ctx context.Context) ([]vfs.Dirent, error) {
 
 	// filesystem.renameMu is needed for d.parent, and must be locked before
 	// d.opMu.
-	d.fs.renameMu.RLock()
-	defer d.fs.renameMu.RUnlock()
+	d.inode.fs.renameMu.RLock()
+	defer d.inode.fs.renameMu.RUnlock()
 	d.opMu.RLock()
 	defer d.opMu.RUnlock()
 
@@ -248,33 +255,33 @@ func (d *dentry) getDirents(ctx context.Context) ([]vfs.Dirent, error) {
 		{
 			Name:    ".",
 			Type:    linux.DT_DIR,
-			Ino:     uint64(d.ino),
+			Ino:     uint64(d.inode.ino),
 			NextOff: 1,
 		},
 		{
 			Name:    "..",
-			Type:    uint8(parent.mode.Load() >> 12),
-			Ino:     uint64(parent.ino),
+			Type:    uint8(parent.inode.mode.Load() >> 12),
+			Ino:     uint64(parent.inode.ino),
 			NextOff: 2,
 		},
 	}
 	var realChildren map[string]struct{}
-	if !d.isSynthetic() {
-		if d.syntheticChildren != 0 && d.fs.opts.interop == InteropModeShared {
+	if !d.inode.isSynthetic() {
+		if d.syntheticChildren != 0 && d.inode.fs.opts.interop == InteropModeShared {
 			// Record the set of children d actually has so that we don't emit
 			// duplicate entries for synthetic children.
 			realChildren = make(map[string]struct{})
 		}
-		d.handleMu.RLock()
-		if !d.isReadHandleOk() {
+		d.inode.handleMu.RLock()
+		if !d.inode.isReadHandleOk() {
 			// This should not be possible because a readable handle should
 			// have been opened when the calling directoryFD was opened.
 			panic("gofer.dentry.getDirents called without a readable handle")
 		}
 		err := d.getDirentsLocked(ctx, func(name string, key inoKey, dType uint8) {
 			dirent := vfs.Dirent{
 				Name:    name,
-				Ino:     d.fs.inoFromKey(key),
+				Ino:     d.inode.fs.inoFromKey(key),
 				NextOff: int64(len(dirents) + 1),
 				Type:    dType,
 			}
@@ -283,7 +290,7 @@ func (d *dentry) getDirents(ctx context.Context) ([]vfs.Dirent, error) {
 				realChildren[name] = struct{}{}
 			}
 		})
-		d.handleMu.RUnlock()
+		d.inode.handleMu.RUnlock()
 		if err != nil {
 			return nil, err
 		}
@@ -292,22 +299,22 @@ func (d *dentry) getDirents(ctx context.Context) ([]vfs.Dirent, error) {
 	// Emit entries for synthetic children.
 	if d.syntheticChildren != 0 {
 		for _, child := range d.children {
-			if child == nil || !child.isSynthetic() {
+			if child == nil || !child.inode.isSynthetic() {
 				continue
 			}
 			if _, ok := realChildren[child.name]; ok {
 				continue
 			}
 			dirents = append(dirents, vfs.Dirent{
 				Name:    child.name,
-				Type:    uint8(child.mode.Load() >> 12),
-				Ino:     uint64(child.ino),
+				Type:    uint8(child.inode.mode.Load() >> 12),
+				Ino:     uint64(child.inode.ino),
 				NextOff: int64(len(dirents) + 1),
 			})
 		}
 	}
 	// Cache dirents for future directoryFDs if permitted.
-	if d.cachedMetadataAuthoritative() {
+	if d.inode.cachedMetadataAuthoritative() {
 		d.dirents = dirents
 		d.childrenSet = make(map[string]struct{}, len(dirents))
 		for _, dirent := range d.dirents {

pkg/sentry/fsimpl/gofer/directory.go

@@ -27,37 +27,47 @@ import (
 func TestDestroyIdempotent(t *testing.T) {
 	ctx := contexttest.Context(t)
 	fs := filesystem{
-		mf:       pgalloc.MemoryFileFromContext(ctx),
-		inoByKey: make(map[inoKey]uint64),
-		clock:    ktime.RealtimeClockFromContext(ctx),
+		mf:         pgalloc.MemoryFileFromContext(ctx),
+		inoByKey:   make(map[inoKey]uint64),
+		inodeByIno: make(map[uint64]*inode),
+		clock:      ktime.RealtimeClockFromContext(ctx),
 		// Test relies on no dentry being held in the cache.
 		dentryCache: &dentryCache{maxCachedDentries: 0},
 		client:      &lisafs.Client{},
 	}
 
-	parentInode := lisafs.Inode{
+	parentRemoteInode := lisafs.Inode{
 		ControlFD: 1,
 		Stat: linux.Statx{
 			Mask: linux.STATX_TYPE | linux.STATX_MODE,
 			Mode: linux.S_IFDIR | 0666,
 		},
 	}
-	parent, err := fs.newLisafsDentry(ctx, &parentInode)
+	parentInode, err := fs.newLisafsInode(ctx, &parentRemoteInode)
 	if err != nil {
-		t.Fatalf("fs.newLisafsDentry(): %v", err)
+		t.Fatalf("fs.newLisafsInode(): %v", err)
+	}
+	parent, err := fs.newDentry(parentInode)
+	if err != nil {
+		t.Fatalf("fs.newDentry(): %v", err)
 	}
 
-	childInode := lisafs.Inode{
+	childRemoteInode := lisafs.Inode{
 		ControlFD: 2,
 		Stat: linux.Statx{
 			Mask: linux.STATX_TYPE | linux.STATX_MODE | linux.STATX_SIZE,
 			Mode: linux.S_IFREG | 0666,
 			Size: 0,
 		},
 	}
-	child, err := fs.newLisafsDentry(ctx, &childInode)
+	childInode, err := fs.newLisafsInode(ctx, &childRemoteInode)
+	if err != nil {
+		t.Fatalf("fs.newLisafsInode(): %v", err)
+	}
+
+	child, err := fs.newDentry(childInode)
 	if err != nil {
-		t.Fatalf("fs.newLisafsDentry(): %v", err)
+		t.Fatalf("fs.newDentry(): %v", err)
 	}
 	parent.opMu.Lock()
 	parent.childrenMu.Lock()

pkg/sentry/fsimpl/gofer/filesystem.go

@@ -67,7 +67,7 @@ func (fs *filesystem) revalidateOne(ctx context.Context, vfsObj *vfs.VirtualFile
 	// Skip revalidation for interop mode different than InteropModeShared or
 	// if the parent is synthetic (child must be synthetic too, but it cannot be
 	// replaced without first replacing the parent).
-	if parent.cachedMetadataAuthoritative() {
+	if parent.inode.cachedMetadataAuthoritative() {
 		return nil
 	}
 
@@ -184,7 +184,7 @@ func (fs *filesystem) revalidateStep(ctx context.Context, rp resolvingPath, d *d
 		state.add(child)
 
 		// Symlink must be resolved before continuing with revalidation.
-		if child.isSymlink() {
+		if child.inode.isSymlink() {
 			return nil, errRevalidationStepDone{}
 		}
 
@@ -211,7 +211,7 @@ func (d *dentry) invalidate(ctx context.Context, vfsObj *vfs.VirtualFilesystem,
 		if child := parent.children[d.name]; child == d {
 			// Invalidate dentry so it gets reloaded next time it's accessed.
 			delete(parent.children, d.name)
-			if d.isSynthetic() {
+			if d.inode.isSynthetic() {
 				// Normally we don't mark invalidated dentries as deleted since
 				// they may still exist (but at a different path), and also for
 				// consistency with Linux. However, synthetic files are
@@ -247,7 +247,7 @@ func (d *dentry) invalidate(ctx context.Context, vfsObj *vfs.VirtualFilesystem,
 		// now. (The same would apply to racy replacement by
 		// filesystem.RenameAt(), but we can't race with rename since renameMu
 		// has been locked since entering filesystem.revalidatePath().)
-		if removed && (d.isSynthetic() || d.endpoint != nil) {
+		if removed && (d.inode.isSynthetic() || d.inode.endpoint != nil) {
 			d.decRefNoCaching()
 		}
 
@@ -282,7 +282,7 @@ func (d *dentry) disownAllChildrenForInvalidation(ctx context.Context, vfsObj *v
 	for name, child := range d.children {
 		children = append(children, child)
 		delete(d.children, name)
-		if child.isSynthetic() {
+		if child.inode.isSynthetic() {
 			child.deleteSynthetic(d, ds)
 		}
 	}

pkg/sentry/fsimpl/gofer/gofer.go

@@ -24,8 +24,8 @@ import (
 	"gvisor.dev/gvisor/pkg/waiter"
 )
 
-func (d *dentry) isSocket() bool {
-	return d.fileType() == linux.S_IFSOCK
+func (i *inode) isSocket() bool {
+	return i.fileType() == linux.S_IFSOCK
 }
 
 func isSocketTypeSupported(sockType linux.SockType) bool {
@@ -103,9 +103,9 @@ func (e *endpoint) UnidirectionalConnect(ctx context.Context, opts transport.Uni
 }
 
 func (e *endpoint) newConnectedEndpoint(ctx context.Context, sockType linux.SockType, queue *waiter.Queue, opts transport.UnixSocketOpts) (*transport.SCMConnectedEndpoint, *syserr.Error) {
-	e.dentry.fs.renameMu.RLock()
+	e.dentry.inode.fs.renameMu.RLock()
 	hostSockFD, err := e.dentry.connect(ctx, sockType)
-	e.dentry.fs.renameMu.RUnlock()
+	e.dentry.inode.fs.renameMu.RUnlock()
 	if err != nil {
 		return nil, syserr.ErrConnectionRefused
 	}

pkg/sentry/fsimpl/gofer/gofer_test.go

@@ -92,7 +92,7 @@ type specialFileFD struct {
 }
 
 func newSpecialFileFD(h handle, mnt *vfs.Mount, d *dentry, flags uint32) (*specialFileFD, error) {
-	ftype := d.fileType()
+	ftype := d.inode.fileType()
 	seekable := ftype == linux.S_IFREG || ftype == linux.S_IFCHR || ftype == linux.S_IFBLK
 	haveQueue := (ftype == linux.S_IFIFO || ftype == linux.S_IFSOCK || ftype == linux.S_IFCHR) && h.fd >= 0
 	fd := &specialFileFD{
@@ -101,7 +101,7 @@ func newSpecialFileFD(h handle, mnt *vfs.Mount, d *dentry, flags uint32) (*speci
 		seekable:      seekable,
 		haveQueue:     haveQueue,
 	}
-	fd.LockFD.Init(&d.locks)
+	fd.LockFD.Init(&d.inode.locks)
 	if haveQueue {
 		if err := fdnotifier.AddFD(h.fd, &fd.queue); err != nil {
 			return nil, err
@@ -117,10 +117,10 @@ func newSpecialFileFD(h handle, mnt *vfs.Mount, d *dentry, flags uint32) (*speci
 		}
 		return nil, err
 	}
-	d.fs.syncMu.Lock()
-	d.fs.specialFileFDs.PushBack(fd)
-	d.fs.syncMu.Unlock()
-	if fd.vfsfd.IsWritable() && (d.mode.Load()&0111 != 0) {
+	d.inode.fs.syncMu.Lock()
+	d.inode.fs.specialFileFDs.PushBack(fd)
+	d.inode.fs.syncMu.Unlock()
+	if fd.vfsfd.IsWritable() && (d.inode.mode.Load()&0111 != 0) {
 		metric.SuspiciousOperationsMetric.Increment(&metric.SuspiciousOperationsTypeOpenedWriteExecuteFile)
 	}
 	if h.fd >= 0 {
@@ -229,7 +229,7 @@ func (fd *specialFileFD) PRead(ctx context.Context, dst usermem.IOSequence, offs
 		return 0, linuxerr.EOPNOTSUPP
 	}
 
-	if d := fd.dentry(); d.cachedMetadataAuthoritative() {
+	if d := fd.dentry(); d.inode.cachedMetadataAuthoritative() {
 		d.touchAtime(fd.vfsfd.Mount())
 	}
 
@@ -304,20 +304,20 @@ func (fd *specialFileFD) pwrite(ctx context.Context, src usermem.IOSequence, off
 		// If the regular file fd was opened with O_APPEND, make sure the file
 		// size is updated. There is a possible race here if size is modified
 		// externally after metadata cache is updated.
-		if fd.vfsfd.StatusFlags()&linux.O_APPEND != 0 && !d.cachedMetadataAuthoritative() {
-			if err := d.updateMetadata(ctx); err != nil {
+		if fd.vfsfd.StatusFlags()&linux.O_APPEND != 0 && !d.inode.cachedMetadataAuthoritative() {
+			if err := d.inode.updateMetadata(ctx); err != nil {
 				return 0, offset, err
 			}
 		}
 
 		// We need to hold the metadataMu *while* writing to a regular file.
-		d.metadataMu.Lock()
-		defer d.metadataMu.Unlock()
+		d.inode.metadataMu.Lock()
+		defer d.inode.metadataMu.Unlock()
 
 		// Set offset to file size if the regular file was opened with O_APPEND.
 		if fd.vfsfd.StatusFlags()&linux.O_APPEND != 0 {
-			// Holding d.metadataMu is sufficient for reading d.size.
-			offset = int64(d.size.RacyLoad())
+			// Holding d.inode.metadataMu is sufficient for reading d.inode.size.
+			offset = int64(d.inode.size.RacyLoad())
 		}
 		limit, err := vfs.CheckLimit(ctx, offset, src.NumBytes())
 		if err != nil {
@@ -326,7 +326,7 @@ func (fd *specialFileFD) pwrite(ctx context.Context, src usermem.IOSequence, off
 		src = src.TakeFirst64(limit)
 	}
 
-	if d.cachedMetadataAuthoritative() {
+	if d.inode.cachedMetadataAuthoritative() {
 		if fd.isRegularFile {
 			d.touchCMtimeLocked()
 		} else {
@@ -335,17 +335,17 @@ func (fd *specialFileFD) pwrite(ctx context.Context, src usermem.IOSequence, off
 	}
 
 	// handleReadWriter always writes to the remote file. So O_DIRECT is
-	// effectively always set. Invalidate pages in d.mappings that have been
+	// effectively always set. Invalidate pages in d.inode.mappings that have been
 	// written to.
 	pgstart := hostarch.PageRoundDown(uint64(offset))
 	pgend, ok := hostarch.PageRoundUp(uint64(offset + src.NumBytes()))
 	if !ok {
 		return 0, offset, linuxerr.EINVAL
 	}
 	mr := memmap.MappableRange{pgstart, pgend}
-	d.mapsMu.Lock()
-	d.mappings.Invalidate(mr, memmap.InvalidateOpts{})
-	d.mapsMu.Unlock()
+	d.inode.mapsMu.Lock()
+	d.inode.mappings.Invalidate(mr, memmap.InvalidateOpts{})
+	d.inode.mapsMu.Unlock()
 
 	rw := getHandleReadWriter(ctx, &fd.handle, offset)
 	n, err := src.CopyInTo(ctx, rw)
@@ -369,11 +369,11 @@ func (fd *specialFileFD) pwrite(ctx context.Context, src usermem.IOSequence, off
 	}
 	// Update file size for regular files.
 	if fd.isRegularFile {
-		// d.metadataMu is already locked at this point.
-		if uint64(offset) > d.size.RacyLoad() {
-			d.dataMu.Lock()
-			defer d.dataMu.Unlock()
-			d.size.Store(uint64(offset))
+		// d.inode.metadataMu is already locked at this point.
+		if uint64(offset) > d.inode.size.RacyLoad() {
+			d.inode.dataMu.Lock()
+			defer d.inode.dataMu.Unlock()
+			d.inode.size.Store(uint64(offset))
 		}
 	}
 	return int64(n), offset, err
@@ -444,19 +444,19 @@ func (fd *specialFileFD) ConfigureMMap(ctx context.Context, opts *memmap.MMapOpt
 // AddMapping implements memmap.Mappable.AddMapping.
 func (fd *specialFileFD) AddMapping(ctx context.Context, ms memmap.MappingSpace, ar hostarch.AddrRange, offset uint64, writable bool) error {
 	d := fd.dentry()
-	d.mapsMu.Lock()
-	defer d.mapsMu.Unlock()
-	d.mappings.AddMapping(ms, ar, offset, writable)
+	d.inode.mapsMu.Lock()
+	defer d.inode.mapsMu.Unlock()
+	d.inode.mappings.AddMapping(ms, ar, offset, writable)
 	fd.hostFileMapper.IncRefOn(memmap.MappableRange{offset, offset + uint64(ar.Length())})
 	return nil
 }
 
 // RemoveMapping implements memmap.Mappable.RemoveMapping.
 func (fd *specialFileFD) RemoveMapping(ctx context.Context, ms memmap.MappingSpace, ar hostarch.AddrRange, offset uint64, writable bool) {
 	d := fd.dentry()
-	d.mapsMu.Lock()
-	defer d.mapsMu.Unlock()
-	d.mappings.RemoveMapping(ms, ar, offset, writable)
+	d.inode.mapsMu.Lock()
+	defer d.inode.mapsMu.Unlock()
+	d.inode.mappings.RemoveMapping(ms, ar, offset, writable)
 	fd.hostFileMapper.DecRefOn(memmap.MappableRange{offset, offset + uint64(ar.Length())})
 }
 
@@ -484,9 +484,9 @@ func (fd *specialFileFD) Translate(ctx context.Context, required, optional memma
 // InvalidateUnsavable implements memmap.Mappable.InvalidateUnsavable.
 func (fd *specialFileFD) InvalidateUnsavable(ctx context.Context) error {
 	d := fd.dentry()
-	d.mapsMu.Lock()
-	defer d.mapsMu.Unlock()
-	d.mappings.InvalidateAll(memmap.InvalidateOpts{})
+	d.inode.mapsMu.Lock()
+	defer d.inode.mapsMu.Unlock()
+	d.inode.mappings.InvalidateAll(memmap.InvalidateOpts{})
 	return nil
 }
 
@@ -532,7 +532,7 @@ func (fd *specialFileFD) requireHostFD() {
 
 func (fd *specialFileFD) updateMetadata(ctx context.Context) error {
 	d := fd.dentry()
-	d.metadataMu.Lock()
-	defer d.metadataMu.Unlock()
-	return d.updateMetadataLocked(ctx, fd.handle)
+	d.inode.metadataMu.Lock()
+	defer d.inode.metadataMu.Unlock()
+	return d.inode.updateMetadataLocked(ctx, fd.handle)
 }

pkg/sentry/fsimpl/gofer/dentry_impl.go renamed to pkg/sentry/fsimpl/gofer/inode_impl.go

@@ -20,28 +20,28 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/vfs"
 )
 
-func (d *dentry) isSymlink() bool {
-	return d.fileType() == linux.S_IFLNK
+func (i *inode) isSymlink() bool {
+	return i.fileType() == linux.S_IFLNK
 }
 
 // Precondition: d.isSymlink().
 func (d *dentry) readlink(ctx context.Context, mnt *vfs.Mount) (string, error) {
-	if d.fs.opts.interop != InteropModeShared {
+	if d.inode.fs.opts.interop != InteropModeShared {
 		d.touchAtime(mnt)
-		d.dataMu.Lock()
-		if d.haveTarget {
-			target := d.target
-			d.dataMu.Unlock()
+		d.inode.dataMu.Lock()
+		if d.inode.haveTarget {
+			target := d.inode.target
+			d.inode.dataMu.Unlock()
 			return target, nil
 		}
 	}
-	target, err := d.readlinkImpl(ctx)
-	if d.fs.opts.interop != InteropModeShared {
+	target, err := d.inode.readlinkImpl(ctx)
+	if d.inode.fs.opts.interop != InteropModeShared {
 		if err == nil {
-			d.haveTarget = true
-			d.target = target
+			d.inode.haveTarget = true
+			d.inode.target = target
 		}
-		d.dataMu.Unlock() // +checklocksforce: guaranteed locked from above.
+		d.inode.dataMu.Unlock() // +checklocksforce: guaranteed locked from above.
 	}
 	return target, err
 }

pkg/sentry/fsimpl/gofer/lisafs_dentry.go renamed to pkg/sentry/fsimpl/gofer/lisafs_inode.go

@@ -36,56 +36,56 @@ func (d *dentry) touchAtime(mnt *vfs.Mount) {
 	if err := mnt.CheckBeginWrite(); err != nil {
 		return
 	}
-	now := d.fs.clock.Now().Nanoseconds()
-	d.metadataMu.Lock()
-	d.atime.Store(now)
-	d.atimeDirty.Store(1)
-	d.metadataMu.Unlock()
+	now := d.inode.fs.clock.Now().Nanoseconds()
+	d.inode.metadataMu.Lock()
+	d.inode.atime.Store(now)
+	d.inode.atimeDirty.Store(1)
+	d.inode.metadataMu.Unlock()
 	mnt.EndWrite()
 }
 
-// Preconditions: d.metadataMu is locked. d.cachedMetadataAuthoritative() == true.
+// Preconditions: d.inode.metadataMu is locked. d.cachedMetadataAuthoritative() == true.
 func (d *dentry) touchAtimeLocked(mnt *vfs.Mount) {
 	if opts := mnt.Options(); opts.Flags.NoATime || opts.ReadOnly {
 		return
 	}
 	if err := mnt.CheckBeginWrite(); err != nil {
 		return
 	}
-	now := d.fs.clock.Now().Nanoseconds()
-	d.atime.Store(now)
-	d.atimeDirty.Store(1)
+	now := d.inode.fs.clock.Now().Nanoseconds()
+	d.inode.atime.Store(now)
+	d.inode.atimeDirty.Store(1)
 	mnt.EndWrite()
 }
 
 // Preconditions:
 //   - d.cachedMetadataAuthoritative() == true.
 //   - The caller has successfully called vfs.Mount.CheckBeginWrite().
 func (d *dentry) touchCtime() {
-	now := d.fs.clock.Now().Nanoseconds()
-	d.metadataMu.Lock()
-	d.ctime.Store(now)
-	d.metadataMu.Unlock()
+	now := d.inode.fs.clock.Now().Nanoseconds()
+	d.inode.metadataMu.Lock()
+	d.inode.ctime.Store(now)
+	d.inode.metadataMu.Unlock()
 }
 
 // Preconditions:
 //   - d.cachedMetadataAuthoritative() == true.
 //   - The caller has successfully called vfs.Mount.CheckBeginWrite().
 func (d *dentry) touchCMtime() {
-	now := d.fs.clock.Now().Nanoseconds()
-	d.metadataMu.Lock()
-	d.mtime.Store(now)
-	d.ctime.Store(now)
-	d.mtimeDirty.Store(1)
-	d.metadataMu.Unlock()
+	now := d.inode.fs.clock.Now().Nanoseconds()
+	d.inode.metadataMu.Lock()
+	d.inode.mtime.Store(now)
+	d.inode.ctime.Store(now)
+	d.inode.mtimeDirty.Store(1)
+	d.inode.metadataMu.Unlock()
 }
 
 // Preconditions:
 //   - d.cachedMetadataAuthoritative() == true.
-//   - The caller has locked d.metadataMu.
+//   - The caller has locked d.inode.metadataMu.
 func (d *dentry) touchCMtimeLocked() {
-	now := d.fs.clock.Now().Nanoseconds()
-	d.mtime.Store(now)
-	d.ctime.Store(now)
-	d.mtimeDirty.Store(1)
+	now := d.inode.fs.clock.Now().Nanoseconds()
+	d.inode.mtime.Store(now)
+	d.inode.ctime.Store(now)
+	d.inode.mtimeDirty.Store(1)
 }

pkg/sentry/fsimpl/gofer/regular_file.go

@@ -344,9 +344,6 @@ syscall_test(
     add_fusefs = True,
     add_overlay = True,
     test = "//test/syscalls/linux:link_test",
-    # TODO(gvisor.dev/issue/6739): Remove use_tmpfs=True once gofer filesystem
-    # supports hard links correctly.
-    use_tmpfs = True,
 )
 
 syscall_test(

pkg/sentry/fsimpl/gofer/revalidate.go

@@ -21,12 +21,13 @@
 
 #include <string>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/flags/flag.h"
 #include "absl/strings/str_cat.h"
-#include "test/util/capability_util.h"
 #include "test/util/file_descriptor.h"
 #include "test/util/fs_util.h"
+#include "test/util/linux_capability_util.h"
 #include "test/util/posix_error.h"
 #include "test/util/temp_path.h"
 #include "test/util/test_util.h"
@@ -51,7 +52,6 @@ bool IsSameFile(const std::string& f1, const std::string& f2) {
 }
 
 // TODO(b/178640646): Add test for linkat with AT_EMPTY_PATH
-
 TEST(LinkTest, CanCreateLinkFile) {
   auto oldfile = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
   const std::string newname = NewTempAbsPath();
@@ -76,6 +76,21 @@ TEST(LinkTest, CanCreateLinkFile) {
               IsPosixErrorOkAndHolds(initial_link_count));
 }
 
+TEST(LinkTest, HardlinkChangeMode) {
+  auto oldfile = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
+  const std::string newname = NewTempAbsPath();
+  struct stat stat1 = {};
+
+  ASSERT_THAT(link(oldfile.path().c_str(), newname.c_str()), SyscallSucceeds());
+
+  EXPECT_TRUE(IsSameFile(oldfile.path(), newname));
+
+  EXPECT_THAT(chmod(oldfile.path().c_str(), S_IRUSR), SyscallSucceeds());
+  EXPECT_THAT(lstat(newname.c_str(), &stat1), SyscallSucceeds());
+  EXPECT_EQ(S_IRUSR, (stat1.st_mode & S_IRWXU));
+  EXPECT_THAT(unlink(newname.c_str()), SyscallSucceeds());
+}
+
 TEST(LinkTest, PermissionDenied) {
   SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_FOWNER)));
 

pkg/sentry/fsimpl/gofer/save_restore.go

@@ -23,6 +23,7 @@
 #include <sys/utsname.h>
 #include <unistd.h>
 
+#include <cstdint>
 #include <ctime>
 #include <iostream>
 #include <vector>
@@ -182,12 +183,14 @@ PosixErrorOr<std::vector<OpenFd>> GetOpenFDs() {
   return ret_fds;
 }
 
+PosixErrorOr<uint64_t> Permissions(const std::string& path) {
+  ASSIGN_OR_RETURN_ERRNO(auto stat_result, Stat(path));
+  return static_cast<uint64_t>(stat_result.st_mode);
+}
+
 PosixErrorOr<uint64_t> Links(const std::string& path) {
-  struct stat st;
-  if (stat(path.c_str(), &st)) {
-    return PosixError(errno, absl::StrCat("Failed to stat ", path));
-  }
-  return static_cast<uint64_t>(st.st_nlink);
+  ASSIGN_OR_RETURN_ERRNO(auto stat_result, Stat(path));
+  return static_cast<uint64_t>(stat_result.st_nlink);
 }
 
 void RandomizeBuffer(char* buffer, size_t len) {