proc: Allow to write into /proc/pid/mem

GDB uses /proc/pid/mem to access memory of the target process.

PiperOrigin-RevId: 756972644

Author: avagin

pkg/sentry/fsimpl/proc/task.go

@@ -71,7 +71,7 @@ func (fs *filesystem) newTaskInode(ctx context.Context, task *kernel.Task, pidns
 		"io":        fs.newTaskOwnedInode(ctx, task, fs.NextIno(), 0400, newIO(task, isThreadGroup)),
 		"limits":    fs.newTaskOwnedInode(ctx, task, fs.NextIno(), 0444, &limitsData{task: task}),
 		"maps":      fs.newTaskOwnedInode(ctx, task, fs.NextIno(), 0444, &mapsData{task: task}),
-		"mem":       fs.newMemInode(ctx, task, fs.NextIno(), 0400),
+		"mem":       fs.newMemInode(ctx, task, fs.NextIno(), 0600),
 		"mountinfo": fs.newTaskOwnedInode(ctx, task, fs.NextIno(), 0444, &mountInfoData{fs: fs, task: task}),
 		"mounts":    fs.newTaskOwnedInode(ctx, task, fs.NextIno(), 0444, &mountsData{fs: fs, task: task}),
 		"net":       fs.newTaskNetDir(ctx, task),

pkg/sentry/fsimpl/proc/task_files.go

@@ -510,6 +510,33 @@ func (fd *memFD) Seek(ctx context.Context, offset int64, whence int32) (int64, e
 	return offset, nil
 }
 
+// PWrite implements vfs.FileDescriptionImpl.PWrite.
+func (fd *memFD) PWrite(ctx context.Context, src usermem.IOSequence, offset int64, opts vfs.WriteOptions) (int64, error) {
+	if src.NumBytes() == 0 {
+		return 0, nil
+	}
+	m, err := getMMIncRef(fd.inode.task)
+	if err != nil {
+		return 0, err
+	}
+	defer m.DecUsers(ctx)
+	// Buffer the read data because of MM locks
+	buf := make([]byte, src.NumBytes())
+	n, readErr := src.CopyIn(ctx, buf)
+	if n > 0 {
+		if n, err := m.CopyOut(ctx, hostarch.Addr(offset), buf[:n], usermem.IOOpts{IgnorePermissions: true}); err != nil {
+			return 0, linuxerr.EFAULT
+		} else {
+			return int64(n), nil
+		}
+	}
+	if readErr != nil {
+		return 0, linuxerr.EIO
+	}
+	return 0, nil
+
+}
+
 // PRead implements vfs.FileDescriptionImpl.PRead.
 func (fd *memFD) PRead(ctx context.Context, dst usermem.IOSequence, offset int64, opts vfs.ReadOptions) (int64, error) {
 	if dst.NumBytes() == 0 {
@@ -535,6 +562,15 @@ func (fd *memFD) PRead(ctx context.Context, dst usermem.IOSequence, offset int64
 	return 0, nil
 }
 
+// Write implements vfs.FileDescriptionImpl.Write.
+func (fd *memFD) Write(ctx context.Context, dst usermem.IOSequence, opts vfs.WriteOptions) (int64, error) {
+	fd.mu.Lock()
+	n, err := fd.PWrite(ctx, dst, fd.offset, opts)
+	fd.offset += n
+	fd.mu.Unlock()
+	return n, err
+}
+
 // Read implements vfs.FileDescriptionImpl.Read.
 func (fd *memFD) Read(ctx context.Context, dst usermem.IOSequence, opts vfs.ReadOptions) (int64, error) {
 	fd.mu.Lock()

test/syscalls/linux/proc.cc

@@ -564,6 +564,27 @@ TEST(ProcPidMem, Read) {
   ASSERT_STREQ(input, output);
 }
 
+TEST(ProcPidMem, PWrite) {
+  auto memfd = ASSERT_NO_ERRNO_AND_VALUE(Open("/proc/self/mem", O_RDWR));
+  char input[] = "hello-world";
+  char output[sizeof(input)];
+  ASSERT_THAT(pwrite(memfd.get(), input, sizeof(input),
+                     reinterpret_cast<off_t>(output)),
+              SyscallSucceedsWithValue(sizeof(input)));
+  ASSERT_STREQ(input, output);
+}
+
+TEST(ProcPidMem, Write) {
+  auto memfd = ASSERT_NO_ERRNO_AND_VALUE(Open("/proc/self/mem", O_RDWR));
+  char input[] = "hello-world";
+  char output[sizeof(input)];
+  ASSERT_THAT(lseek(memfd.get(), reinterpret_cast<off_t>(output), SEEK_SET),
+              SyscallSucceedsWithValue(reinterpret_cast<off_t>(output)));
+  ASSERT_THAT(write(memfd.get(), input, sizeof(input)),
+              SyscallSucceedsWithValue(sizeof(input)));
+  ASSERT_STREQ(input, output);
+}
+
 // Perform read on an unmapped region.
 TEST(ProcPidMem, Unmapped) {
   // Strategy: map then unmap, so we have a guaranteed unmapped region