[PATCH v5 12/25] AArch64: Implement memory tagging target methods for AArch64

Luis Machado via Gdb-patches
2021-01-27T20:21:54Z

Updates on v4:

- Update naming and attributes of the functions.
- Call get_ptrace_pid.
- Misc fixes to formatting.
- Use enum instead of magic integers.

Updates on v2:

- Added type parameter to the target method implementations.

--

The patch implements the memory tagging target hooks for AArch64, so we
can handle MTE.

gdb/ChangeLog:

YYYY-MM-DD Luis Machado <luis.machado@linaro.org>

* Makefile.in (ALL_64_TARGET_OBS): Add arch/aarch64-mte-linux.o.
(HFILES_NO_SRCDIR): Add arch/aarch64-mte-linux.h and
nat/aarch64-mte-linux-ptrace.h.
* aarch64-linux-nat.c: Include nat/aarch64-mte-linux-ptrace.h.
(aarch64_linux_nat_target) <supports_memory_tagging>: New method
override.
<fetch_memtags>: New method override.
<store_memtags>: New method override.
(aarch64_linux_nat_target::supports_memory_tagging): New method.
(aarch64_linux_nat_target::fetch_memtags): New method.
(aarch64_linux_nat_target::store_memtags): New method.
* arch/aarch64-mte-linux.c: New file.
* arch/aarch64-mte-linux.h: Include gdbsupport/common-defs.h.
(AARCH64_MTE_GRANULE_SIZE): Define.
(aarch64_memtag_type): New enum.
(aarch64_mte_get_tag_granules): New prototype.
* configure.nat (NATDEPFILES): Add nat/aarch64-mte-linux-ptrace.o.
* configure.tgt (aarch64*-*-linux*): Add arch/aarch64-mte-linux.o.
* nat/aarch64-mte-linux-ptrace.c: New file.
* nat/aarch64-mte-linux-ptrace.h: New file.
---
gdb/Makefile.in | 1 +
gdb/aarch64-linux-nat.c | 50 ++++++++
gdb/arch/aarch64-mte-linux.c | 34 +++++
gdb/arch/aarch64-mte-linux.h | 19 +++
gdb/configure.nat | 3 +-
gdb/configure.tgt | 1 +
gdb/nat/aarch64-mte-linux-ptrace.c | 200 +++++++++++++++++++++++++++++
gdb/nat/aarch64-mte-linux-ptrace.h | 17 +++
8 files changed, 324 insertions(+), 1 deletion(-)
create mode 100644 gdb/arch/aarch64-mte-linux.c
create mode 100644 gdb/nat/aarch64-mte-linux-ptrace.c

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index b763351912..26f1aff4d5 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -698,6 +698,7 @@ ALL_64_TARGET_OBS = \
amd64-windows-tdep.o \
arch/aarch64.o \
arch/aarch64-insn.o \
+ arch/aarch64-mte-linux.o \
arch/amd64.o \
ia64-linux-tdep.o \
ia64-tdep.o \
diff --git a/gdb/aarch64-linux-nat.c b/gdb/aarch64-linux-nat.c
index fe3ba44c55..c8f09d5b22 100644
--- a/gdb/aarch64-linux-nat.c
+++ b/gdb/aarch64-linux-nat.c
@@ -52,6 +52,8 @@

#include "arch/aarch64-mte-linux.h"

+#include "nat/aarch64-mte-linux-ptrace.h"
+
#ifndef TRAP_HWBKPT
#define TRAP_HWBKPT 0x0004
#endif
@@ -102,6 +104,16 @@ class aarch64_linux_nat_target final : public linux_nat_target
override;

struct gdbarch *thread_architecture (ptid_t) override;
+
+ bool supports_memory_tagging () override;
+
+ /* Read memory allocation tags from memory via PTRACE. */
+ bool fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type) override;
+
+ /* Write allocation tags to memory via PTRACE. */
+ bool store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type) override;
};

static aarch64_linux_nat_target the_aarch64_linux_nat_target;
@@ -1054,6 +1066,44 @@ aarch64_linux_nat_target::thread_architecture (ptid_t ptid)
return gdbarch_find_by_info (info);
}

+/* Implement the "supports_memory_tagging" target_ops method. */
+
+bool
+aarch64_linux_nat_target::supports_memory_tagging ()
+{
+ return (linux_get_hwcap2 (this) & HWCAP2_MTE) != 0;
+}
+
+/* Implement the "fetch_memtags" target_ops method. */
+
+bool
+aarch64_linux_nat_target::fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type)
+{
+ int tid = get_ptrace_pid (inferior_ptid);
+
+ /* Allocation tags? */
+ if (type == static_cast <int> (aarch64_memtag_type::mte_allocation))
+ return aarch64_mte_fetch_memtags (tid, address, len, tags);
+
+ return false;
+}
+
+/* Implement the "store_memtags" target_ops method. */
+
+bool
+aarch64_linux_nat_target::store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type)
+{
+ int tid = get_ptrace_pid (inferior_ptid);
+
+ /* Allocation tags? */
+ if (type == static_cast <int> (aarch64_memtag_type::mte_allocation))
+ return aarch64_mte_store_memtags (tid, address, len, tags);
+
+ return false;
+}
+
/* Define AArch64 maintenance commands. */

static void
diff --git a/gdb/arch/aarch64-mte-linux.c b/gdb/arch/aarch64-mte-linux.c
new file mode 100644
index 0000000000..ede5f5f2b9
--- /dev/null
+++ b/gdb/arch/aarch64-mte-linux.c
@@ -0,0 +1,34 @@
+/* Common Linux target-dependent functionality for AArch64 MTE
+
+ Copyright (C) 2020 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "arch/aarch64-mte-linux.h"
+
+/* See arch/aarch64-mte-linux.h */
+
+size_t
+aarch64_mte_get_tag_granules (CORE_ADDR addr, size_t len, size_t granule_size)
+{
+ /* Start address */
+ CORE_ADDR s_addr = align_down (addr, granule_size);
+ /* End address */
+ CORE_ADDR e_addr = align_down (addr + len, granule_size);
+
+ /* We always have at least 1 granule. */
+ return 1 + (e_addr - s_addr) / granule_size;
+}
diff --git a/gdb/arch/aarch64-mte-linux.h b/gdb/arch/aarch64-mte-linux.h
index 4124e80543..108031e08a 100644
--- a/gdb/arch/aarch64-mte-linux.h
+++ b/gdb/arch/aarch64-mte-linux.h
@@ -20,6 +20,8 @@
#ifndef ARCH_AARCH64_LINUX_H
#define ARCH_AARCH64_LINUX_H

+#include "gdbsupport/common-defs.h"
+
/* Feature check for Memory Tagging Extension. */
#ifndef HWCAP2_MTE
#define HWCAP2_MTE (1 << 18)
@@ -28,4 +30,21 @@
/* The MTE regset consists of a single 64-bit register. */
#define AARCH64_LINUX_SIZEOF_MTE 8

+/* We have one tag per 16 bytes of memory. */
+#define AARCH64_MTE_GRANULE_SIZE 16
+
+/* Memory tag types for AArch64. */
+enum class aarch64_memtag_type
+{
+ /* MTE logical tag contained in pointers. */
+ mte_logical = 0,
+ /* MTE allocation tag stored in memory tag granules. */
+ mte_allocation
+};
+
+/* Return the number of tag granules in the memory range
+ [ADDR, ADDR + LEN) given GRANULE_SIZE. */
+extern size_t aarch64_mte_get_tag_granules (CORE_ADDR addr, size_t len,
+ size_t granule_size);
+
#endif /* ARCH_AARCH64_LINUX_H */
diff --git a/gdb/configure.nat b/gdb/configure.nat
index 286975966d..e34cccffd9 100644
--- a/gdb/configure.nat
+++ b/gdb/configure.nat
@@ -236,7 +236,8 @@ case ${gdb_host} in
NATDEPFILES="${NATDEPFILES} aarch64-linux-nat.o \
aarch32-linux-nat.o nat/aarch64-linux-hw-point.o \
nat/aarch64-linux.o \
- nat/aarch64-sve-linux-ptrace.o"
+ nat/aarch64-sve-linux-ptrace.o \
+ nat/aarch64-mte-linux-ptrace.o"
;;
arc)
# Host: ARC based machine running GNU/Linux
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index 6e03983874..1c7a8919db 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -125,6 +125,7 @@ aarch64*-*-freebsd*)
aarch64*-*-linux*)
# Target: AArch64 linux
gdb_target_obs="aarch64-linux-tdep.o arch/aarch64.o\
+ arch/aarch64-mte-linux.o \
arch/arm.o arch/arm-linux.o arch/arm-get-next-pcs.o \
arm-tdep.o arm-linux-tdep.o \
glibc-tdep.o linux-tdep.o solib-svr4.o \
diff --git a/gdb/nat/aarch64-mte-linux-ptrace.c b/gdb/nat/aarch64-mte-linux-ptrace.c
new file mode 100644
index 0000000000..be4f2b93d8
--- /dev/null
+++ b/gdb/nat/aarch64-mte-linux-ptrace.c
@@ -0,0 +1,200 @@
+/* Common Linux native ptrace code for AArch64 MTE.
+
+ Copyright (C) 2020 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "gdbsupport/common-defs.h"
+#include "gdbsupport/byte-vector.h"
+
+#include "arch/aarch64.h"
+#include "arch/aarch64-mte-linux.h"
+#include "nat/aarch64-linux.h"
+#include "nat/aarch64-mte-linux-ptrace.h"
+
+#include "linux-ptrace.h"
+#include <sys/uio.h>
+
+/* Helper function to display various possible errors when reading
+ MTE tags. */
+
+static void ATTRIBUTE_NORETURN
+aarch64_mte_linux_peek_error (int error)
+{
+ switch (error)
+ {
+ case EIO:
+ perror_with_name (_("PEEKMTETAGS not supported"));
+ break;
+ case EFAULT:
+ perror_with_name (_("Couldn't fetch allocation tags"));
+ break;
+ case EOPNOTSUPP:
+ perror_with_name (_("PROT_ME not enabled for requested address"));
+ default:
+ perror_with_name (_("Unknown MTE error"));
+ break;
+ }
+}
+
+/* Helper function to display various possible errors when writing
+ MTE tags. */
+
+static void ATTRIBUTE_NORETURN
+aarch64_mte_linux_poke_error (int error)
+{
+ switch (error)
+ {
+ case EIO:
+ perror_with_name (_("POKEMTETAGS not supported"));
+ break;
+ case EFAULT:
+ perror_with_name (_("Couldn't store allocation tags"));
+ break;
+ case EOPNOTSUPP:
+ perror_with_name (_("PROT_ME not enabled for requested address"));
+ default:
+ perror_with_name (_("Unknown MTE error"));
+ break;
+ }
+}
+
+/* Helper to prepare a vector of tags to be passed on to the kernel. The
+ main purpose of this function is to optimize the number of calls to
+ ptrace if we're writing too many tags at once, like a pattern fill
+ request.
+
+ Return a vector of tags of up to MAX_SIZE size, containing the tags that
+ must be passed on to the kernel, extracted from TAGS, starting at POS.
+ GRANULES is the number of tag granules to be modified. */
+
+static gdb::byte_vector
+prepare_tag_vector (size_t granules, const gdb::byte_vector &tags, size_t pos,
+ size_t max_size)
+{
+ gdb::byte_vector t;
+
+ if (granules == 0)
+ return t;
+
+ gdb_assert (tags.size () > 0 && max_size > 0);
+
+ if (granules > AARCH64_MTE_TAGS_MAX_SIZE)
+ t.resize (AARCH64_MTE_TAGS_MAX_SIZE);
+ else
+ t.resize (granules);
+
+ size_t tag_count = tags.size ();
+
+ for (size_t i = 0; i < t.size (); i++)
+ t[i] = tags[(pos + i) % tag_count];
+
+ return t;
+}
+
+/* See nat/aarch64-mte-linux-ptrace.h */
+
+bool
+aarch64_mte_fetch_memtags (int tid, CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags)
+{
+ size_t ntags = aarch64_mte_get_tag_granules (address, len,
+ AARCH64_MTE_GRANULE_SIZE);
+ gdb_byte tagbuf[ntags];
+
+ struct iovec iovec;
+ iovec.iov_base = tagbuf;
+ iovec.iov_len = ntags;
+
+ tags.clear ();
+ bool done_reading = false;
+
+ /* The kernel may return less tags than we requested. Loop until we've read
+ all the requested tags or until we get an error. */
+ while (!done_reading)
+ {
+ /* Attempt to read ntags allocation tags from the kernel. */
+ if (ptrace (PTRACE_PEEKMTETAGS, tid, address, &iovec) < 0)
+ aarch64_mte_linux_peek_error (errno);
+
+ /* Make sure the kernel returned at least one tag. */
+ if (iovec.iov_len <= 0)
+ {
+ tags.clear ();
+ return false;
+ }
+
+ /* Copy the tags the kernel returned. */
+ for (size_t i = 0; i < iovec.iov_len; i++)
+ tags.push_back (tagbuf[i]);
+
+ /* Are we done reading tags? */
+ if (tags.size () == ntags)
+ done_reading = true;
+ else
+ {
+ address += iovec.iov_len * AARCH64_MTE_GRANULE_SIZE;
+ iovec.iov_len = ntags - iovec.iov_len;
+ }
+ }
+ return true;
+}
+
+/* See nat/aarch64-mte-linux-ptrace.h */
+
+bool
+aarch64_mte_store_memtags (int tid, CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags)
+{
+ if (tags.size () == 0)
+ return true;
+
+ /* Get the number of tags we need to write. */
+ size_t ntags = aarch64_mte_get_tag_granules (address, len,
+ AARCH64_MTE_GRANULE_SIZE);
+ bool done_writing = false;
+ size_t tags_written = 0;
+
+ /* Write all the tags, AARCH64_MTE_TAGS_MAX_SIZE blocks at a time. */
+ while (!done_writing)
+ {
+ gdb::byte_vector t = prepare_tag_vector (ntags - tags_written, tags,
+ tags_written,
+ AARCH64_MTE_TAGS_MAX_SIZE);
+
+ struct iovec iovec;
+ iovec.iov_base = t.data ();
+ iovec.iov_len = t.size ();
+
+ /* Request the kernel to update the allocation tags. */
+ if (ptrace (PTRACE_POKEMTETAGS, tid, address, &iovec) < 0)
+ aarch64_mte_linux_poke_error (errno);
+
+ /* Make sure the kernel wrote at least one tag. */
+ if (iovec.iov_len <= 0)
+ return false;
+
+ tags_written += iovec.iov_len;
+
+ /* Are we done writing tags? */
+ if (tags_written == ntags)
+ done_writing = true;
+ else
+ address += iovec.iov_len * AARCH64_MTE_GRANULE_SIZE;
+ }
+
+ return true;
+}
diff --git a/gdb/nat/aarch64-mte-linux-ptrace.h b/gdb/nat/aarch64-mte-linux-ptrace.h
index 099b6440ca..eb2b471893 100644
--- a/gdb/nat/aarch64-mte-linux-ptrace.h
+++ b/gdb/nat/aarch64-mte-linux-ptrace.h
@@ -30,4 +30,21 @@
#define PTRACE_POKEMTETAGS 34
#endif

+/* Maximum number of tags to pass at once to the kernel. */
+#define AARCH64_MTE_TAGS_MAX_SIZE 4096
+
+/* Read the allocation tags from memory range [ADDRESS, ADDRESS + LEN)
+ into TAGS.
+
+ Returns true if successful and false otherwise. */
+extern bool aarch64_mte_fetch_memtags (int tid, CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags);
+
+/* Write the TAGS allocation tags to the memory range
+ [ADDRESS, ADDRESS + LEN).
+
+ Returns true if successful and false otherwise. */
+extern bool aarch64_mte_store_memtags (int tid, CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags);
+
#endif /* NAT_AARCH64_MTE_LINUX_PTRACE_H */
--
2.25.1