@@ -21,12 +21,15 @@ import (
2121
2222 "gvisor.dev/gvisor/pkg/abi/linux"
2323 "gvisor.dev/gvisor/pkg/atomicbitops"
24+ "gvisor.dev/gvisor/pkg/cleanup"
2425 "gvisor.dev/gvisor/pkg/context"
2526 "gvisor.dev/gvisor/pkg/errors/linuxerr"
2627 "gvisor.dev/gvisor/pkg/fdnotifier"
2728 "gvisor.dev/gvisor/pkg/hostarch"
29+ "gvisor.dev/gvisor/pkg/log"
2830 "gvisor.dev/gvisor/pkg/refs"
2931 "gvisor.dev/gvisor/pkg/safemem"
32+ "gvisor.dev/gvisor/pkg/sentry/kernel/auth"
3033 "gvisor.dev/gvisor/pkg/sentry/pgalloc"
3134 "gvisor.dev/gvisor/pkg/sentry/vfs"
3235)
@@ -50,6 +53,7 @@ func (fs *filesystem) PrepareSave(ctx context.Context) error {
5053 fs .renameMu .Lock ()
5154 fs .evictAllCachedDentriesLocked (ctx )
5255 fs .renameMu .Unlock ()
56+ fs .savedDentryRW = make (map [* dentry ]savedDentryRW )
5357
5458 // Buffer pipe data so that it's available for reading after restore. (This
5559 // is a legacy VFS1 feature.)
@@ -62,14 +66,23 @@ func (fs *filesystem) PrepareSave(ctx context.Context) error {
6266 }
6367 }
6468 }
69+ // Save file data for deleted regular files which are still accessible via
70+ // open application FDs.
71+ for sd := fs .syncableDentries .Front (); sd != nil ; sd = sd .Next () {
72+ if sd .d .vfsd .IsDead () {
73+ if err := sd .d .prepareSaveDead (ctx ); err != nil {
74+ fs .syncMu .Unlock ()
75+ return err
76+ }
77+ }
78+ }
6579 fs .syncMu .Unlock ()
6680
6781 // Flush local state to the remote filesystem.
6882 if err := fs .Sync (ctx ); err != nil {
6983 return err
7084 }
7185
72- fs .savedDentryRW = make (map [* dentry ]savedDentryRW )
7386 return fs .root .prepareSaveRecursive (ctx )
7487}
7588
@@ -98,6 +111,62 @@ func (fd *specialFileFD) savePipeData(ctx context.Context) error {
98111 return nil
99112}
100113
114+ func (d * dentry ) prepareSaveDead (ctx context.Context ) error {
115+ if ! d .isRegularFile () {
116+ return fmt .Errorf ("gofer.dentry(%q).prepareSaveDead: only regular deleted dentries can be saved, got %s" , genericDebugPathname (d .fs , d ), linux .FileMode (d .mode .Load ()))
117+ }
118+ if ! d .isDeleted () {
119+ return fmt .Errorf ("gofer.dentry(%q).prepareSaveDead: invalidated dentries can't be saved" , genericDebugPathname (d .fs , d ))
120+ }
121+ if ! d .cachedMetadataAuthoritative () {
122+ if err := d .updateMetadata (ctx ); err != nil {
123+ return err
124+ }
125+ }
126+ if d .isReadHandleOk () || d .isWriteHandleOk () {
127+ d .fs .savedDentryRW [d ] = savedDentryRW {
128+ read : d .isReadHandleOk (),
129+ write : d .isWriteHandleOk (),
130+ }
131+ }
132+ d .handleMu .RLock ()
133+ defer d .handleMu .RUnlock ()
134+ var h handle
135+ if d .isReadHandleOk () {
136+ h = d .readHandle ()
137+ } else {
138+ var err error
139+ h , err = d .openHandle (ctx , true /* read */ , false /* write */ , false /* trunc */ )
140+ if err != nil {
141+ return fmt .Errorf ("failed to open read handle for deleted file %q: %w" , genericDebugPathname (d .fs , d ), err )
142+ }
143+ defer h .close (ctx )
144+ }
145+ d .dataMu .RLock ()
146+ defer d .dataMu .RUnlock ()
147+ d .deletedDataSR = make ([]byte , d .size .Load ())
148+ done := uint64 (0 )
149+ for done < uint64 (len (d .deletedDataSR )) {
150+ n , err := h .readToBlocksAt (ctx , safemem .BlockSeqOf (safemem .BlockFromSafeSlice (d .deletedDataSR [done :])), done )
151+ done += n
152+ if err != nil {
153+ if err == io .EOF {
154+ break
155+ }
156+ return fmt .Errorf ("failed to read deleted file %q: %w" , genericDebugPathname (d .fs , d ), err )
157+ }
158+ }
159+ if done < uint64 (len (d .deletedDataSR )) {
160+ return fmt .Errorf ("failed to read all of deleted file %q: read %d bytes, expected %d" , genericDebugPathname (d .fs , d ), done , len (d .deletedDataSR ))
161+ }
162+ d .deletedDataSR = d .deletedDataSR [:done ]
163+ if d .fs .savedDeletedOpenDentries == nil {
164+ d .fs .savedDeletedOpenDentries = make (map [* dentry ]struct {})
165+ }
166+ d .fs .savedDeletedOpenDentries [d ] = struct {}{}
167+ return nil
168+ }
169+
101170func (d * dentry ) prepareSaveRecursive (ctx context.Context ) error {
102171 if d .isRegularFile () && ! d .cachedMetadataAuthoritative () {
103172 // Get updated metadata for d in case we need to perform metadata
@@ -131,13 +200,17 @@ func (d *dentry) prepareSaveRecursive(ctx context.Context) error {
131200
132201// beforeSave is invoked by stateify.
133202func (d * dentry ) beforeSave () {
134- if d .vfsd .IsDead () {
203+ if d .vfsd .IsDead () && d . deletedDataSR == nil {
135204 panic (fmt .Sprintf ("gofer.dentry(%q).beforeSave: deleted and invalidated dentries can't be restored" , genericDebugPathname (d .fs , d )))
136205 }
137206}
138207
139208// BeforeResume implements vfs.FilesystemImplSaveRestoreExtension.BeforeResume.
140209func (fs * filesystem ) BeforeResume (ctx context.Context ) {
210+ for d := range fs .savedDeletedOpenDentries {
211+ d .deletedDataSR = nil
212+ }
213+ fs .savedDeletedOpenDentries = nil
141214 fs .savedDentryRW = nil
142215}
143216
@@ -236,7 +309,15 @@ func (fs *filesystem) CompleteRestore(ctx context.Context, opts vfs.CompleteRest
236309 }
237310 }
238311
312+ // Restore deleted files which are still accessible via open application FDs.
313+ for d := range fs .savedDeletedOpenDentries {
314+ if err := d .restoreDead (ctx , & opts ); err != nil {
315+ return err
316+ }
317+ }
318+
239319 // Discard state only required during restore.
320+ fs .savedDeletedOpenDentries = nil
240321 fs .savedDentryRW = nil
241322
242323 return nil
@@ -263,6 +344,48 @@ func (d *dentry) restoreDescendantsRecursive(ctx context.Context, opts *vfs.Comp
263344 return nil
264345}
265346
347+ // restoreDead restores a deleted regular file.
348+ //
349+ // Preconditions: d.deletedDataSR != nil.
350+ func (d * dentry ) restoreDead (ctx context.Context , opts * vfs.CompleteRestoreOptions ) error {
351+ // Recreate the file on the host filesystem (this is temporary).
352+ parent := d .parent .Load ()
353+ _ , h , err := parent .openCreate (ctx , d .name , linux .O_WRONLY , linux .FileMode (d .mode .Load ()), auth .KUID (d .uid .Load ()), auth .KGID (d .gid .Load ()), false /* createDentry */ )
354+ if err != nil {
355+ return fmt .Errorf ("failed to re-create deleted file %q: %w" , genericDebugPathname (d .fs , d ), err )
356+ }
357+ defer h .close (ctx )
358+ // In case of errors, clean up the recreated file.
359+ cu := cleanup .Make (func () {
360+ if err := parent .unlink (ctx , d .name , 0 /* flags */ ); err != nil {
361+ log .Warningf ("failed to clean up recreated deleted file %q: %v" , genericDebugPathname (d .fs , d ), err )
362+ }
363+ })
364+ defer cu .Clean ()
365+ // Write the file data to the recreated file.
366+ n , err := h .writeFromBlocksAt (ctx , safemem .BlockSeqOf (safemem .BlockFromSafeSlice (d .deletedDataSR )), 0 )
367+ if err != nil {
368+ return fmt .Errorf ("failed to write deleted file %q: %w" , genericDebugPathname (d .fs , d ), err )
369+ }
370+ if n != uint64 (len (d .deletedDataSR )) {
371+ return fmt .Errorf ("failed to write all of deleted file %q: wrote %d bytes, expected %d" , genericDebugPathname (d .fs , d ), n , len (d .deletedDataSR ))
372+ }
373+ d .deletedDataSR = nil
374+ // Restore the file. Note that timestamps may not match since we re-created
375+ // the file on the host.
376+ recreateOpts := * opts
377+ recreateOpts .ValidateFileModificationTimestamps = false
378+ if err := d .restoreFile (ctx , & recreateOpts ); err != nil {
379+ return err
380+ }
381+ // Finally, unlink the recreated file.
382+ cu .Release ()
383+ if err := parent .unlink (ctx , d .name , 0 /* flags */ ); err != nil {
384+ return fmt .Errorf ("failed to clean up recreated deleted file %q: %v" , genericDebugPathname (d .fs , d ), err )
385+ }
386+ return nil
387+ }
388+
266389func (fd * specialFileFD ) completeRestore (ctx context.Context ) error {
267390 d := fd .dentry ()
268391 h , err := d .openHandle (ctx , fd .vfsfd .IsReadable (), fd .vfsfd .IsWritable (), false /* trunc */ )
0 commit comments