From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-qt1-x830.google.com (mail-qt1-x830.google.com [IPv6:2607:f8b0:4864:20::830]) by sourceware.org (Postfix) with ESMTPS id 177F6385481F for ; Mon, 22 Mar 2021 13:21:40 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 177F6385481F Received: by mail-qt1-x830.google.com with SMTP id f12so12248066qtq.4 for ; Mon, 22 Mar 2021 06:21:40 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=WjaEqyaL4Oqmm53D+tmpwVksU7D7fFh4J/lq/J7PFEM=; b=Ni6/r7xRM1qS6p7mM8mTgj/J5sZfh8xWrvx5J+o65H1jmp06eLS872a8J+3kXv5mfj TSZ8dI9/Nncxg2MEjHGJGwoUfrA9SduD3dF6U0HAm0tmbHl0wtJNjnPx2FuBAgP+6eMb 74YRKXUY9Oep2XkOufG0mdXEhyeLth53kLVouUlcovDezRlV0spi20ZtcaD9DkYKv/Q4 Pd2TxUziqRgfk55Cl1DYHajaqH1qAWmeVsPU7MjwzEU3A7SCVIynTNAv72nw6swJjKkX t2EDVnXsJ1JBMXAl/+VEwsrRqpfn38XXcCOXOIaeImMkNIxREj8VDUVUVyBrLvrHGSm/ pZ+A== X-Gm-Message-State: AOAM533S8rugIwETcNIcrgtD8jquo6aQ6eY6CZz03ezL0du1vU4zTJoH Fo61j2ROlmZihwqnQmuAyCFVyptHovQa8A== X-Google-Smtp-Source: ABdhPJyEi+AzHbYK+FAsrAy/ycJI0s0Ie+aFPUA7d0ZqBGHsuVpKcJO5pliFzDvy496gYzTFb9JIvg== X-Received: by 2002:ac8:3a67:: with SMTP id w94mr9480683qte.31.1616419299423; Mon, 22 Mar 2021 06:21:39 -0700 (PDT) Received: from localhost.localdomain ([2804:7f0:4841:2841:2c21:ec8a:30f3:55a6]) by smtp.gmail.com with ESMTPSA id r35sm7364575qtd.95.2021.03.22.06.21.37 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 22 Mar 2021 06:21:38 -0700 (PDT) From: Luis Machado To: gdb-patches@sourceware.org Subject: [PATCH v6 05/25] GDBserver remote packet support for memory tagging Date: Mon, 22 Mar 2021 10:20:59 -0300 Message-Id: <20210322132120.1202230-6-luis.machado@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210322132120.1202230-1-luis.machado@linaro.org> References: <20210322132120.1202230-1-luis.machado@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 22 Mar 2021 13:21:42 -0000 Updates on v6: - Move function documentation to header file and update it. Updates on v4: - Updated naming of helper functions. - Updated return types from int to bool. - Removed return type for functions not returning a value. - Updated code documentation. Updates on v2: - Update target methods to contain a tag type field. - Update remote packet processing to parse the type field. -- This patch adds the generic remote bits to gdbserver so it can check for memory tagging support and handle fetch tags and store tags requests. gdbserver/ChangeLog: YYYY-MM-DD Luis Machado * remote-utils.cc (decode_m_packet_params): Renamed from ... (decode_m_packet): ... this, which now calls decode_m_packet_params. Make char * param/return const char *. (decode_M_packet): Use decode_m_packet_params and make char * param const char *. * remote-utils.h (decode_m_packet_params): New prototype. (decode_m_packet): Constify char pointers. (decode_M_packet): Likewise. * server.cc (create_fetch_memtags_reply) (parse_store_memtags_request): New functions. (handle_general_set): Handle the QMemTags packet. (parse_fetch_memtags_request): New function. (handle_query): Handle the qMemTags packet and advertise memory tagging support. (captured_main): Initialize memory tagging flag. * server.h (struct client_state): Initialize memory tagging flag. * target.cc (process_stratum_target::supports_memory_tagging) (process_stratum_target::fetch_memtags) (process_stratum_target::store_memtags): New methods. * target.h: Include gdbsupport/byte-vector.h. (class process_stratum_target) : New class virtual methods. (target_supports_memory_tagging): Define. --- gdbserver/remote-utils.cc | 42 ++++++------ gdbserver/remote-utils.h | 12 +++- gdbserver/server.cc | 140 ++++++++++++++++++++++++++++++++++++++ gdbserver/server.h | 3 + gdbserver/target.cc | 20 ++++++ gdbserver/target.h | 21 ++++++ 6 files changed, 213 insertions(+), 25 deletions(-) diff --git a/gdbserver/remote-utils.cc b/gdbserver/remote-utils.cc index 509b813af27..198a75a4476 100644 --- a/gdbserver/remote-utils.cc +++ b/gdbserver/remote-utils.cc @@ -1308,10 +1308,13 @@ prepare_resume_reply (char *buf, ptid_t ptid, } } -void -decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr) +/* See remote-utils.h. */ + +const char * +decode_m_packet_params (const char *from, CORE_ADDR *mem_addr_ptr, + unsigned int *len_ptr, const char end_marker) { - int i = 0, j = 0; + int i = 0; char ch; *mem_addr_ptr = *len_ptr = 0; @@ -1321,39 +1324,32 @@ decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr) *mem_addr_ptr |= fromhex (ch) & 0x0f; } - for (j = 0; j < 4; j++) + while ((ch = from[i++]) != end_marker) { - if ((ch = from[i++]) == 0) - break; *len_ptr = *len_ptr << 4; *len_ptr |= fromhex (ch) & 0x0f; } + + return from + i; } void -decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, - unsigned char **to_p) +decode_m_packet (const char *from, CORE_ADDR *mem_addr_ptr, + unsigned int *len_ptr) { - int i = 0; - char ch; - *mem_addr_ptr = *len_ptr = 0; - - while ((ch = from[i++]) != ',') - { - *mem_addr_ptr = *mem_addr_ptr << 4; - *mem_addr_ptr |= fromhex (ch) & 0x0f; - } + decode_m_packet_params (from, mem_addr_ptr, len_ptr, '\0'); +} - while ((ch = from[i++]) != ':') - { - *len_ptr = *len_ptr << 4; - *len_ptr |= fromhex (ch) & 0x0f; - } +void +decode_M_packet (const char *from, CORE_ADDR *mem_addr_ptr, + unsigned int *len_ptr, unsigned char **to_p) +{ + from = decode_m_packet_params (from, mem_addr_ptr, len_ptr, ':'); if (*to_p == NULL) *to_p = (unsigned char *) xmalloc (*len_ptr); - hex2bin (&from[i++], *to_p, *len_ptr); + hex2bin (from, *to_p, *len_ptr); } int diff --git a/gdbserver/remote-utils.h b/gdbserver/remote-utils.h index 5a8e764cbc5..25074bcc2b9 100644 --- a/gdbserver/remote-utils.h +++ b/gdbserver/remote-utils.h @@ -45,9 +45,17 @@ void prepare_resume_reply (char *buf, ptid_t ptid, const char *decode_address_to_semicolon (CORE_ADDR *addrp, const char *start); void decode_address (CORE_ADDR *addrp, const char *start, int len); -void decode_m_packet (char *from, CORE_ADDR * mem_addr_ptr, + +/* Given an input string FROM, decode MEM_ADDR_PTR, a memory address in hex + form, and LEN_PTR, a length argument in hex form, from the pattern + ",", with END_MARKER being an end marker + character. */ +const char *decode_m_packet_params (const char *from, CORE_ADDR *mem_addr_ptr, + unsigned int *len_ptr, + const char end_marker); +void decode_m_packet (const char *from, CORE_ADDR * mem_addr_ptr, unsigned int *len_ptr); -void decode_M_packet (char *from, CORE_ADDR * mem_addr_ptr, +void decode_M_packet (const char *from, CORE_ADDR * mem_addr_ptr, unsigned int *len_ptr, unsigned char **to_p); int decode_X_packet (char *from, int packet_len, CORE_ADDR * mem_addr_ptr, unsigned int *len_ptr, unsigned char **to_p); diff --git a/gdbserver/server.cc b/gdbserver/server.cc index ea731d54689..5887133390a 100644 --- a/gdbserver/server.cc +++ b/gdbserver/server.cc @@ -556,6 +556,64 @@ handle_btrace_conf_general_set (char *own_buf) return 1; } +/* Create the qMemTags packet reply given TAGS. + + Returns true if parsing succeeded and false otherwise. */ + +static bool +create_fetch_memtags_reply (char *reply, const gdb::byte_vector &tags) +{ + /* It is an error to pass a zero-sized tag vector. */ + gdb_assert (tags.size () != 0); + + std::string packet ("m"); + + /* Write the tag data. */ + packet += bin2hex (tags.data (), tags.size ()); + + /* Check if the reply is too big for the packet to handle. */ + if (PBUFSIZ < packet.size ()) + return false; + + strcpy (reply, packet.c_str ()); + return true; +} + +/* Parse the QMemTags request into ADDR, LEN and TAGS. + + Returns true if parsing succeeded and false otherwise. */ + +static bool +parse_store_memtags_request (char *request, CORE_ADDR *addr, size_t *len, + gdb::byte_vector &tags, int *type) +{ + gdb_assert (startswith (request, "QMemTags:")); + + const char *p = request + strlen ("QMemTags:"); + + /* Read address and length. */ + unsigned int length = 0; + p = decode_m_packet_params (p, addr, &length, ':'); + *len = length; + + /* Read the tag type. */ + ULONGEST tag_type = 0; + p = unpack_varlen_hex (p, &tag_type); + *type = (int) tag_type; + + /* Make sure there is a colon after the type. */ + if (*p != ':') + return false; + + /* Skip the colon. */ + p++; + + /* Read the tag data. */ + tags = hex2bin (p); + + return true; +} + /* Handle all of the extended 'Q' packets. */ static void @@ -912,6 +970,32 @@ handle_general_set (char *own_buf) return; } + + /* Handle store memory tags packets. */ + if (startswith (own_buf, "QMemTags:") + && target_supports_memory_tagging ()) + { + gdb::byte_vector tags; + CORE_ADDR addr = 0; + size_t len = 0; + int type = 0; + + require_running_or_return (own_buf); + + int ret = parse_store_memtags_request (own_buf, &addr, &len, tags, + &type); + + if (ret == 0) + ret = the_target->store_memtags (addr, len, tags, type); + + if (ret) + write_enn (own_buf); + else + write_ok (own_buf); + + return; + } + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; @@ -2076,6 +2160,27 @@ crc32 (CORE_ADDR base, int len, unsigned int crc) return (unsigned long long) crc; } +/* Parse the qMemTags packet request into ADDR and LEN. */ + +static void +parse_fetch_memtags_request (char *request, CORE_ADDR *addr, size_t *len, + int *type) +{ + gdb_assert (startswith (request, "qMemTags:")); + + const char *p = request + strlen ("qMemTags:"); + + /* Read address and length. */ + unsigned int length = 0; + p = decode_m_packet_params (p, addr, &length, ':'); + *len = length; + + /* Read the tag type. */ + ULONGEST tag_type = 0; + p = unpack_varlen_hex (p, &tag_type); + *type = (int) tag_type; +} + /* Add supported btrace packets to BUF. */ static void @@ -2294,6 +2399,12 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) events. */ report_no_resumed = true; } + else if (feature == "memory-tagging+") + { + /* GDB supports memory tagging features. */ + if (target_supports_memory_tagging ()) + cs.memory_tagging_feature = true; + } else { /* Move the unknown features all together. */ @@ -2411,6 +2522,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) strcat (own_buf, ";no-resumed+"); + if (target_supports_memory_tagging ()) + strcat (own_buf, ";memory-tagging+"); + /* Reinitialize components as needed for the new connection. */ hostio_handle_new_gdb_connection (); target_handle_new_gdb_connection (); @@ -2603,6 +2717,31 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_tracepoints () && handle_tracepoint_query (own_buf)) return; + /* Handle fetch memory tags packets. */ + if (startswith (own_buf, "qMemTags:") + && target_supports_memory_tagging ()) + { + gdb::byte_vector tags; + CORE_ADDR addr = 0; + size_t len = 0; + int type = 0; + + require_running_or_return (own_buf); + + parse_fetch_memtags_request (own_buf, &addr, &len, &type); + + int ret = the_target->fetch_memtags (addr, len, tags, type); + + if (ret) + ret = create_fetch_memtags_reply (own_buf, tags); + + if (ret) + write_enn (own_buf); + + *new_packet_len_p = strlen (own_buf); + return; + } + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; @@ -3822,6 +3961,7 @@ captured_main (int argc, char *argv[]) cs.swbreak_feature = 0; cs.hwbreak_feature = 0; cs.vCont_supported = 0; + cs.memory_tagging_feature = false; remote_open (port); diff --git a/gdbserver/server.h b/gdbserver/server.h index 416544c1f39..3e280732a89 100644 --- a/gdbserver/server.h +++ b/gdbserver/server.h @@ -190,6 +190,9 @@ struct client_state int current_traceframe = -1; + /* If true, memory tagging features are supported. */ + bool memory_tagging_feature = false; + }; client_state &get_client_state (); diff --git a/gdbserver/target.cc b/gdbserver/target.cc index 4c6f77501b7..1f2159714b3 100644 --- a/gdbserver/target.cc +++ b/gdbserver/target.cc @@ -464,6 +464,26 @@ process_stratum_target::supports_read_offsets () return false; } +bool +process_stratum_target::supports_memory_tagging () +{ + return false; +} + +bool +process_stratum_target::fetch_memtags (CORE_ADDR address, size_t len, + gdb::byte_vector &tags, int type) +{ + gdb_assert_not_reached ("target op fetch_memtags not supported"); +} + +bool +process_stratum_target::store_memtags (CORE_ADDR address, size_t len, + const gdb::byte_vector &tags, int type) +{ + gdb_assert_not_reached ("target op store_memtags not supported"); +} + int process_stratum_target::read_offsets (CORE_ADDR *text, CORE_ADDR *data) { diff --git a/gdbserver/target.h b/gdbserver/target.h index 336ee5ad9db..2831a6ce7c0 100644 --- a/gdbserver/target.h +++ b/gdbserver/target.h @@ -30,6 +30,7 @@ #include "gdbsupport/array-view.h" #include "gdbsupport/btrace-common.h" #include +#include "gdbsupport/byte-vector.h" struct emit_ops; struct buffer; @@ -499,6 +500,23 @@ class process_stratum_target /* Return tdesc index for IPA. */ virtual int get_ipa_tdesc_idx (); + + /* Returns true if the target supports memory tagging facilities. */ + virtual bool supports_memory_tagging (); + + /* Return the allocated memory tags of type TYPE associated with + [ADDRESS, ADDRESS + LEN) in TAGS. + + Returns true if successful and false otherwise. */ + virtual bool fetch_memtags (CORE_ADDR address, size_t len, + gdb::byte_vector &tags, int type); + + /* Write the allocation tags of type TYPE contained in TAGS to the + memory range [ADDRESS, ADDRESS + LEN). + + Returns true if successful and false otherwise. */ + virtual bool store_memtags (CORE_ADDR address, size_t len, + const gdb::byte_vector &tags, int type); }; extern process_stratum_target *the_target; @@ -525,6 +543,9 @@ int kill_inferior (process_info *proc); #define target_supports_exec_events() \ the_target->supports_exec_events () +#define target_supports_memory_tagging() \ + the_target->supports_memory_tagging () + #define target_handle_new_gdb_connection() \ the_target->handle_new_gdb_connection () -- 2.25.1