Update Waitable API.

Instead of passing the event mask at registratrion time, pass the mask as part
of the waiter. This makes the mask immutable and simplifies the architecture of
waiters. This is also necessary for a future fix that will allow the fdnotifier
to keep persistent entries, as opposed to requiring constant updates.

This change is intended to be a no-op in terms of function. The only exception
is signalfd, where this mask was abused. To handle this case, the operation of
signalfd changed to allow one layer of indirection.

PiperOrigin-RevId: 409702998

pkg/sentry/socket/netstack/netstack.go

@@ -436,8 +436,8 @@ func (s *socketOpsCommon) isPacketBased() bool {
 
 // Release implements fs.FileOperations.Release.
 func (s *socketOpsCommon) Release(ctx context.Context) {
-	e, ch := waiter.NewChannelEntry(nil)
-	s.EventRegister(&e, waiter.EventHUp|waiter.EventErr)
+	e, ch := waiter.NewChannelEntry(waiter.EventHUp | waiter.EventErr)
+	s.EventRegister(&e)
 	defer s.EventUnregister(&e)
 
 	s.Endpoint.Close()
@@ -615,8 +615,8 @@ func (s *socketOpsCommon) Connect(t *kernel.Task, sockaddr []byte, blocking bool
 
 	// Register for notification when the endpoint becomes writable, then
 	// initiate the connection.
-	e, ch := waiter.NewChannelEntry(nil)
-	s.EventRegister(&e, waiter.WritableEvents)
+	e, ch := waiter.NewChannelEntry(waiter.WritableEvents)
+	s.EventRegister(&e)
 	defer s.EventUnregister(&e)
 
 	switch err := s.Endpoint.Connect(addr); err.(type) {
@@ -712,8 +712,8 @@ func (s *socketOpsCommon) Listen(_ *kernel.Task, backlog int) *syserr.Error {
 // connections are ready to be accept, it will block until one becomes ready.
 func (s *socketOpsCommon) blockingAccept(t *kernel.Task, peerAddr *tcpip.FullAddress) (tcpip.Endpoint, *waiter.Queue, *syserr.Error) {
 	// Register for notifications.
-	e, ch := waiter.NewChannelEntry(nil)
-	s.EventRegister(&e, waiter.ReadableEvents)
+	e, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
+	s.EventRegister(&e)
 	defer s.EventUnregister(&e)
 
 	// Try to accept the connection again; if it fails, then wait until we
@@ -2858,8 +2858,8 @@ func (s *socketOpsCommon) RecvMsg(t *kernel.Task, dst usermem.IOSequence, flags
 
 	// We'll have to block. Register for notifications and keep trying to
 	// send all the data.
-	e, ch := waiter.NewChannelEntry(nil)
-	s.EventRegister(&e, waiter.ReadableEvents)
+	e, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
+	s.EventRegister(&e)
 	defer s.EventUnregister(&e)
 
 	for {
@@ -2945,8 +2945,8 @@ func (s *socketOpsCommon) SendMsg(t *kernel.Task, src usermem.IOSequence, to []b
 			if ch == nil {
 				// We'll have to block. Register for notification and keep trying to
 				// send all the data.
-				entry, ch = waiter.NewChannelEntry(nil)
-				s.EventRegister(&entry, waiter.WritableEvents)
+				entry, ch = waiter.NewChannelEntry(waiter.WritableEvents)
+				s.EventRegister(&entry)
 				defer s.EventUnregister(&entry)
 			} else {
 				// Don't wait immediately after registration in case more data

pkg/sentry/socket/netstack/netstack_vfs2.go

@@ -90,8 +90,8 @@ func (s *SocketVFS2) Readiness(mask waiter.EventMask) waiter.EventMask {
 }
 
 // EventRegister implements waiter.Waitable.EventRegister.
-func (s *SocketVFS2) EventRegister(e *waiter.Entry, mask waiter.EventMask) {
-	s.socketOpsCommon.EventRegister(e, mask)
+func (s *SocketVFS2) EventRegister(e *waiter.Entry) {
+	s.socketOpsCommon.EventRegister(e)
 }
 
 // EventUnregister implements waiter.Waitable.EventUnregister.