[PATCH 7/7] Implement vFile:setfs in gdbserver

Gary Benson
2015-04-16T12:54:43Z

gdb/gdbserver/ChangeLog:

* target.h (struct target_ops) <call_with_fs_of>: New field.
* linux-low.c (nat/linux-namespaces.h): New include.
(linux_low_call_with_fs_of): New function.
* linux-low.c (linux_target_ops): Initialize call_with_fs_of.
* hostio.c (hostio_fs_pid): New static variable.
(handle_setfs): New function.
(enter_filesystem): Likewise.
(open_closure): New structure.
(handle_open_1): New function.
(handle_open): Update to use enter_filesystem.
(unlink_closure): New structure.
(handle_unlink_1): New function.
(handle_unlink): Update to use enter_filesystem.
(readlink_closure): New structure.
(handle_readlink_1): New function.
(handle_readlink): Update to use enter_filesystem.
(handle_vFile): Handle vFile:setfs packets.
---
gdb/gdbserver/ChangeLog | 20 ++++++
gdb/gdbserver/hostio.c | 152 ++++++++++++++++++++++++++++++++++++++++----
gdb/gdbserver/linux-low.c | 10 +++
gdb/gdbserver/target.h | 6 ++
4 files changed, 174 insertions(+), 14 deletions(-)

diff --git a/gdb/gdbserver/hostio.c b/gdb/gdbserver/hostio.c
index b03b5ad..9a1e443 100644
--- a/gdb/gdbserver/hostio.c
+++ b/gdb/gdbserver/hostio.c
@@ -243,6 +243,51 @@ hostio_reply_with_data (char *own_buf, char *buffer, int len,
return input_index;
}

+/* Process ID of inferior whose filesystem hostio functions
+ that take FILENAME arguments will use. Zero means to use
+ our own filesystem. */
+
+static int hostio_fs_pid = 0;
+
+/* Handle a "vFile:setfs:" packet. */
+
+static void
+handle_setfs (char *own_buf)
+{
+ char *p;
+ int pid;
+
+ p = own_buf + strlen ("vFile:setfs:");
+
+ if (require_int (&p, &pid)
+ || pid < 0
+ || require_end (p))
+ {
+ hostio_packet_error (own_buf);
+ return;
+ }
+
+ hostio_fs_pid = pid;
+
+ hostio_reply (own_buf, 0);
+}
+
+/* Cause the filesystem to appear as it does to the process specified
+ by the most recent valid "vFile:setfs:" packet and call FUNC with
+ argument ARG, restoring the filesystem to its original state
+ afterwards. Return nonzero if FUNC was called, zero otherwise (and
+ set ERRNO). */
+
+static int
+enter_filesystem (void (*func) (void *), void *arg)
+{
+ if (hostio_fs_pid != 0 && the_target->call_with_fs_of != NULL)
+ return the_target->call_with_fs_of (hostio_fs_pid, func, arg);
+
+ func (arg);
+ return 1;
+}
+
static int
fileio_open_flags_to_host (int fileio_open_flags, int *open_flags_p)
{
@@ -275,23 +320,45 @@ fileio_open_flags_to_host (int fileio_open_flags, int *open_flags_p)
return 0;
}

+/* Arguments and return value of open(2). */
+
+struct open_closure
+{
+ char filename[HOSTIO_PATH_MAX];
+ int flags;
+ int mode;
+ int return_value;
+};
+
+/* Helper for handle_open. */
+
+static void
+handle_open_1 (void *arg)
+{
+ struct open_closure *clo = (struct open_closure *) arg;
+
+ clo->return_value = open (clo->filename, clo->flags, clo->mode);
+}
+
+/* Handle a "vFile:open:" packet. */
+
static void
handle_open (char *own_buf)
{
- char filename[HOSTIO_PATH_MAX];
char *p;
- int fileio_flags, mode, flags, fd;
+ int fileio_flags, fd;
struct fd_list *new_fd;
+ struct open_closure clo;

p = own_buf + strlen ("vFile:open:");

- if (require_filename (&p, filename)
+ if (require_filename (&p, clo.filename)
|| require_comma (&p)
|| require_int (&p, &fileio_flags)
|| require_comma (&p)
- || require_int (&p, &mode)
+ || require_int (&p, &clo.mode)
|| require_end (p)
- || fileio_open_flags_to_host (fileio_flags, &flags))
+ || fileio_open_flags_to_host (fileio_flags, &clo.flags))
{
hostio_packet_error (own_buf);
return;
@@ -299,7 +366,11 @@ handle_open (char *own_buf)

/* We do not need to convert MODE, since the fileio protocol
uses the standard values. */
- fd = open (filename, flags, mode);
+
+ if (enter_filesystem (handle_open_1, &clo))
+ fd = clo.return_value;
+ else
+ fd = -1;

if (fd == -1)
{
@@ -487,23 +558,46 @@ handle_close (char *own_buf)
hostio_reply (own_buf, ret);
}

+/* Arguments and return value of unlink(2). */
+
+struct unlink_closure
+{
+ char filename[HOSTIO_PATH_MAX];
+ int return_value;
+};
+
+/* Helper for handle_unlink. */
+
+static void
+handle_unlink_1 (void *arg)
+{
+ struct unlink_closure *clo = (struct unlink_closure *) arg;
+
+ clo->return_value = unlink (clo->filename);
+}
+
+/* Handle a "vFile:unlink:" packet. */
+
static void
handle_unlink (char *own_buf)
{
- char filename[HOSTIO_PATH_MAX];
+ struct unlink_closure clo;
char *p;
int ret;

p = own_buf + strlen ("vFile:unlink:");

- if (require_filename (&p, filename)
+ if (require_filename (&p, clo.filename)
|| require_end (p))
{
hostio_packet_error (own_buf);
return;
}

- ret = unlink (filename);
+ if (enter_filesystem (handle_unlink_1, &clo))
+ ret = clo.return_value;
+ else
+ ret = -1;

if (ret == -1)
{
@@ -514,30 +608,57 @@ handle_unlink (char *own_buf)
hostio_reply (own_buf, ret);
}

+/* Arguments and return value of readlink(2). */
+
+struct readlink_closure
+{
+ char filename[HOSTIO_PATH_MAX];
+ char linkname[HOSTIO_PATH_MAX];
+ int return_value;
+};
+
+/* Helper for handle_readlink. */
+
+static void
+handle_readlink_1 (void *arg)
+{
+ struct readlink_closure *clo = (struct readlink_closure *) arg;
+
+ clo->return_value = readlink (clo->filename, clo->linkname,
+ sizeof (clo->linkname) - 1);
+}
+
+/* Handle a "vFile:readlink:" packet. */
+
static void
handle_readlink (char *own_buf, int *new_packet_len)
{
- char filename[HOSTIO_PATH_MAX], linkname[HOSTIO_PATH_MAX];
+ struct readlink_closure clo;
char *p;
int ret, bytes_sent;

p = own_buf + strlen ("vFile:readlink:");

- if (require_filename (&p, filename)
+ if (require_filename (&p, clo.filename)
|| require_end (p))
{
hostio_packet_error (own_buf);
return;
}

- ret = readlink (filename, linkname, sizeof (linkname) - 1);
+ if (enter_filesystem (handle_readlink_1, &clo))
+ ret = clo.return_value;
+ else
+ ret = -1;
+
if (ret == -1)
{
hostio_error (own_buf);
return;
}

- bytes_sent = hostio_reply_with_data (own_buf, linkname, ret, new_packet_len);
+ bytes_sent = hostio_reply_with_data (own_buf, clo.linkname,
+ ret, new_packet_len);

/* If the response does not fit into a single packet, do not attempt
to return a partial response, but simply fail. */
@@ -550,7 +671,10 @@ handle_readlink (char *own_buf, int *new_packet_len)
int
handle_vFile (char *own_buf, int packet_len, int *new_packet_len)
{
- if (startswith (own_buf, "vFile:open:"))
+ if (the_target->call_with_fs_of != NULL
+ && startswith (own_buf, "vFile:setfs:"))
+ handle_setfs (own_buf);
+ else if (startswith (own_buf, "vFile:open:"))
handle_open (own_buf);
else if (startswith (own_buf, "vFile:pread:"))
handle_pread (own_buf, new_packet_len);
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 74f754d..4f01dbd 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -51,6 +51,7 @@
definition of elf_fpregset_t. */
#include <elf.h>
#endif
+#include "nat/linux-namespaces.h"

#ifndef SPUFS_MAGIC
#define SPUFS_MAGIC 0x23c9b64e
@@ -6349,6 +6350,14 @@ current_lwp_ptid (void)
return ptid_of (current_thread);
}

+/* Implementation of target_ops->call_with_fs_of. */
+
+static int
+linux_low_call_with_fs_of (int pid, void (*func) (void *), void *arg)
+{
+ return linux_ns_enter (pid, LINUX_NS_MNT, func, arg);
+}
+
static struct target_ops linux_target_ops = {
linux_create_inferior,
linux_attach,
@@ -6434,6 +6443,7 @@ static struct target_ops linux_target_ops = {
#endif
linux_supports_range_stepping,
linux_proc_pid_to_exec_file,
+ linux_low_call_with_fs_of,
};

static void
diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h
index 6280c26..c766a2c 100644
--- a/gdb/gdbserver/target.h
+++ b/gdb/gdbserver/target.h
@@ -402,6 +402,12 @@ struct target_ops
string should be copied into a buffer by the client if the string
will not be immediately used, or if it must persist. */
char *(*pid_to_exec_file) (int pid);
+
+ /* Cause the filesystem to appear as it does to process PID and
+ call FUNC with argument ARG, restoring the filesystem to its
+ original state afterwards. Return nonzero if FUNC was called,
+ zero otherwise (and set ERRNO). */
+ int (*call_with_fs_of) (int pid, void (*func) (void *), void *arg);
};

extern struct target_ops *the_target;
--
1.7.1