Merge release-20210315.0-23-ge7ca2a51a (automated)

3 files changed, 21 insertions, 21 deletions

diff --git a/pkg/sentry/kernel/pipe/pipe.go b/pkg/sentry/kernel/pipe/pipe.go
index 68a55a186..d004f2357 100644
--- a/pkg/sentry/kernel/pipe/pipe.go
+++ b/pkg/sentry/kernel/pipe/pipe.go
@@ -183,7 +183,7 @@ func (p *Pipe) Open(ctx context.Context, d *fs.Dirent, flags fs.FileFlags) *fs.F
 //
 // peekLocked does not mutate the pipe; if the read consumes bytes from the
 // pipe, then the caller is responsible for calling p.consumeLocked() and
-// p.Notify(waiter.EventOut). (The latter must be called with p.mu unlocked.)
+// p.Notify(waiter.WritableEvents). (The latter must be called with p.mu unlocked.)
 //
 // Preconditions:
 // * p.mu must be locked.
@@ -237,7 +237,7 @@ func (p *Pipe) consumeLocked(n int64) {
 // Unlike peekLocked, writeLocked assumes that f returns the number of bytes
 // written to the pipe, and increases the number of bytes stored in the pipe
 // accordingly. Callers are still responsible for calling
-// p.Notify(waiter.EventIn) with p.mu unlocked.
+// p.Notify(waiter.ReadableEvents) with p.mu unlocked.
 //
 // Preconditions:
 // * p.mu must be locked.
@@ -357,7 +357,7 @@ func (p *Pipe) HasWriters() bool {
 func (p *Pipe) rReadinessLocked() waiter.EventMask {
 	ready := waiter.EventMask(0)
 	if p.HasReaders() && p.size != 0 {
-		ready |= waiter.EventIn
+		ready |= waiter.ReadableEvents
 	}
 	if !p.HasWriters() && p.hadWriter {
 		// POLLHUP must be suppressed until the pipe has had at least one writer
@@ -383,7 +383,7 @@ func (p *Pipe) rReadiness() waiter.EventMask {
 func (p *Pipe) wReadinessLocked() waiter.EventMask {
 	ready := waiter.EventMask(0)
 	if p.HasWriters() && p.size < p.max {
-		ready |= waiter.EventOut
+		ready |= waiter.WritableEvents
 	}
 	if !p.HasReaders() {
 		ready |= waiter.EventErr
diff --git a/pkg/sentry/kernel/pipe/pipe_util.go b/pkg/sentry/kernel/pipe/pipe_util.go
index 76ea389ca..2d89b9ccd 100644
--- a/pkg/sentry/kernel/pipe/pipe_util.go
+++ b/pkg/sentry/kernel/pipe/pipe_util.go
@@ -39,14 +39,14 @@ func (p *Pipe) Release(context.Context) {
 	p.wClose()
 
 	// Wake up readers and writers.
-	p.Notify(waiter.EventIn | waiter.EventOut)
+	p.Notify(waiter.ReadableEvents | waiter.WritableEvents)
 }
 
 // Read reads from the Pipe into dst.
 func (p *Pipe) Read(ctx context.Context, dst usermem.IOSequence) (int64, error) {
 	n, err := dst.CopyOutFrom(ctx, p)
 	if n > 0 {
-		p.Notify(waiter.EventOut)
+		p.Notify(waiter.WritableEvents)
 	}
 	return n, err
 }
@@ -75,7 +75,7 @@ func (p *Pipe) WriteTo(ctx context.Context, w io.Writer, count int64, dup bool)
 		return safemem.FromIOWriter{w}.WriteFromBlocks(srcs)
 	}, !dup /* removeFromSrc */)
 	if n > 0 && !dup {
-		p.Notify(waiter.EventOut)
+		p.Notify(waiter.WritableEvents)
 	}
 	return n, err
 }
@@ -84,7 +84,7 @@ func (p *Pipe) WriteTo(ctx context.Context, w io.Writer, count int64, dup bool)
 func (p *Pipe) Write(ctx context.Context, src usermem.IOSequence) (int64, error) {
 	n, err := src.CopyInTo(ctx, p)
 	if n > 0 {
-		p.Notify(waiter.EventIn)
+		p.Notify(waiter.ReadableEvents)
 	}
 	return n, err
 }
@@ -109,7 +109,7 @@ func (p *Pipe) ReadFrom(ctx context.Context, r io.Reader, count int64) (int64, e
 		return safemem.FromIOReader{r}.ReadToBlocks(dsts)
 	})
 	if n > 0 {
-		p.Notify(waiter.EventIn)
+		p.Notify(waiter.ReadableEvents)
 	}
 	return n, err
 }
diff --git a/pkg/sentry/kernel/pipe/vfs.go b/pkg/sentry/kernel/pipe/vfs.go
index 09c0ccaf2..e524afad5 100644
--- a/pkg/sentry/kernel/pipe/vfs.go
+++ b/pkg/sentry/kernel/pipe/vfs.go
@@ -194,11 +194,11 @@ func (fd *VFSPipeFD) Release(context.Context) {
 	var event waiter.EventMask
 	if fd.vfsfd.IsReadable() {
 		fd.pipe.rClose()
-		event |= waiter.EventOut
+		event |= waiter.WritableEvents
 	}
 	if fd.vfsfd.IsWritable() {
 		fd.pipe.wClose()
-		event |= waiter.EventIn | waiter.EventHUp
+		event |= waiter.ReadableEvents | waiter.EventHUp
 	}
 	if event == 0 {
 		panic("invalid pipe flags: must be readable, writable, or both")
@@ -293,7 +293,7 @@ func (fd *VFSPipeFD) SpliceToNonPipe(ctx context.Context, out *vfs.FileDescripti
 	fd.pipe.mu.Unlock()
 
 	if n > 0 {
-		fd.pipe.Notify(waiter.EventOut)
+		fd.pipe.Notify(waiter.WritableEvents)
 	}
 	return n, err
 }
@@ -318,14 +318,14 @@ func (fd *VFSPipeFD) SpliceFromNonPipe(ctx context.Context, in *vfs.FileDescript
 	fd.pipe.mu.Unlock()
 
 	if n > 0 {
-		fd.pipe.Notify(waiter.EventIn)
+		fd.pipe.Notify(waiter.ReadableEvents)
 	}
 	return n, err
 }
 
 // CopyIn implements usermem.IO.CopyIn. Note that it is the caller's
 // responsibility to call fd.pipe.consumeLocked() and
-// fd.pipe.Notify(waiter.EventOut) after the read is completed.
+// fd.pipe.Notify(waiter.WritableEvents) after the read is completed.
 //
 // Preconditions: fd.pipe.mu must be locked.
 func (fd *VFSPipeFD) CopyIn(ctx context.Context, addr usermem.Addr, dst []byte, opts usermem.IOOpts) (int, error) {
@@ -336,8 +336,8 @@ func (fd *VFSPipeFD) CopyIn(ctx context.Context, addr usermem.Addr, dst []byte,
 }
 
 // CopyOut implements usermem.IO.CopyOut. Note that it is the caller's
-// responsibility to call fd.pipe.Notify(waiter.EventIn) after the
-// write is completed.
+// responsibility to call fd.pipe.Notify(waiter.ReadableEvents) after the write
+// is completed.
 //
 // Preconditions: fd.pipe.mu must be locked.
 func (fd *VFSPipeFD) CopyOut(ctx context.Context, addr usermem.Addr, src []byte, opts usermem.IOOpts) (int, error) {
@@ -359,7 +359,7 @@ func (fd *VFSPipeFD) ZeroOut(ctx context.Context, addr usermem.Addr, toZero int6
 
 // CopyInTo implements usermem.IO.CopyInTo. Note that it is the caller's
 // responsibility to call fd.pipe.consumeLocked() and
-// fd.pipe.Notify(waiter.EventOut) after the read is completed.
+// fd.pipe.Notify(waiter.WritableEvents) after the read is completed.
 //
 // Preconditions: fd.pipe.mu must be locked.
 func (fd *VFSPipeFD) CopyInTo(ctx context.Context, ars usermem.AddrRangeSeq, dst safemem.Writer, opts usermem.IOOpts) (int64, error) {
@@ -369,8 +369,8 @@ func (fd *VFSPipeFD) CopyInTo(ctx context.Context, ars usermem.AddrRangeSeq, dst
 }
 
 // CopyOutFrom implements usermem.IO.CopyOutFrom. Note that it is the caller's
-// responsibility to call fd.pipe.Notify(waiter.EventIn) after the write is
-// completed.
+// responsibility to call fd.pipe.Notify(waiter.ReadableEvents) after the write
+// is completed.
 //
 // Preconditions: fd.pipe.mu must be locked.
 func (fd *VFSPipeFD) CopyOutFrom(ctx context.Context, ars usermem.AddrRangeSeq, src safemem.Reader, opts usermem.IOOpts) (int64, error) {
@@ -431,9 +431,9 @@ func spliceOrTee(ctx context.Context, dst, src *VFSPipeFD, count int64, removeFr
 	src.pipe.mu.Unlock()
 
 	if n > 0 {
-		dst.pipe.Notify(waiter.EventIn)
+		dst.pipe.Notify(waiter.ReadableEvents)
 		if removeFromSrc {
-			src.pipe.Notify(waiter.EventOut)
+			src.pipe.Notify(waiter.WritableEvents)
 		}
 	}
 	return n, err