From nobody Sun Apr 12 00:55:46 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; arc=pass (i=1 dmarc=pass fromdomain=epfl.ch); dmarc=pass(p=quarantine dis=none) header.from=epfl.ch ARC-Seal: i=2; a=rsa-sha256; t=1772460341; cv=pass; d=zohomail.com; s=zohoarc; b=WtFTlGI1ftPHqq7+WoRH2EcMg7M80Ug/YIwVjA6lwUsPzcuspugaOOzmfm5eE7LNoEfdhYymQ9WrpUZX5uKQA9LWLesvqPoVR4xfjmRMHS1b11D999goQ7e87P5IKHj/qDbBCRACzhcmwD4vOm1WaSdLHIiRPa+AhlJIsqmk68Y= ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1772460341; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=Mc8d1+imrsWx3XRJ95PRKYs/hR1p9upNC0FbNzCZ19k=; b=b2xSgOZGOQjAR3JPKiYcV77Pay5yEz87nZS5fr/hCokJRqziFjtujTsmWCfQ7YrZubx1CNYkQ4CsRg3rC4dp4TtdJIIHxoAkvPr1jibRMmlRm86XcknvlCIykdS5zB60QdPMLoEkSRkxK9bkgWTZU6q8zZcAU1nUIBHmGd5mkCE= ARC-Authentication-Results: i=2; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; arc=pass (i=1 dmarc=pass fromdomain=epfl.ch); dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1772460341325134.56963579478486; Mon, 2 Mar 2026 06:05:41 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vx3td-00067k-DZ; Mon, 02 Mar 2026 09:05:18 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vx3sb-00056J-8l for qemu-devel@nongnu.org; Mon, 02 Mar 2026 09:04:24 -0500 Received: from mail-switzerlandwestazlp170100001.outbound.protection.outlook.com ([2a01:111:f403:c214::1] helo=GVAP278CU002.outbound.protection.outlook.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vx3sV-0003rA-C0 for qemu-devel@nongnu.org; Mon, 02 Mar 2026 09:04:12 -0500 Received: from ZRH2PFAD84B9AF9.CHEP278.PROD.OUTLOOK.COM (2603:10a6:918::220) by GV0P278MB1029.CHEP278.PROD.OUTLOOK.COM (2603:10a6:710:4e::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9654.21; Mon, 2 Mar 2026 14:03:48 +0000 Received: from ZRH2PFAD84B9AF9.CHEP278.PROD.OUTLOOK.COM ([fe80::80ea:3d03:40bf:998c]) by ZRH2PFAD84B9AF9.CHEP278.PROD.OUTLOOK.COM ([fe80::80ea:3d03:40bf:998c%6]) with mapi id 15.20.9654.020; Mon, 2 Mar 2026 14:03:48 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=vJR9NjNHvZ2mqHm4IX0irhcV6YyrzsosgFckWdzk1obrOBwdpkgbjWcWVHbn3V9fI9l+qLbKZuWbukVkM9dqXN7OKZ4koCvzi4WhH6qZCjeqFsm/xclR9EBngO/8bfG4gtN4sW+UASIRqMuBqBY+pvOHQczlY6adBrcEyDaWJ9K09vrzXCLWP49Pmk+4BZCVdg+Sn8yu5a6d50/HYxWejtH7Y939+WzleCZ+PrkXKrdRE/SaiW9kmQnoEhsvh6IUYLkMxot2qWRycHqvqhq/EtJLw8Os5wbn1jbH/GCTVSVwDSeYgykM8daLp6OqzxtlSRuPNfEx+3bkJWg/Cme0eQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=Mc8d1+imrsWx3XRJ95PRKYs/hR1p9upNC0FbNzCZ19k=; b=b4xbpp//9Yf+SYVvBGSz9OyPiPiHWe4h9kG8/O/wjmgolEV0JiDRnXYDzcuZi7bnLSKcxUbwPHfp56DTLJ/AbIhn58/fC4LTrR+Zm5Zkrlarx9NZE/VATkiDQg9ZgHdjlzTo3sdpMdbEJh3fE3Y06ImoWHQiHuRcU2jDuww9FIvQi3M5qxAbXhQ9Y2RMPAD3gu/tJc6OFdC3wAAmdMTPLe01nAIjglj/xA5qJBmxpBJ1auoIHQp90TJR2dJ0MSlEmmbYtAaIX8ehzET8eCgN2QFu68qk0Cf5drLARkLMy5oF7Q6mzC/mQ34/OpuU/LNt2H6WohGSg3TgP7teIHpPjg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=epfl.ch; dmarc=pass action=none header.from=epfl.ch; dkim=pass header.d=epfl.ch; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=epfl.ch; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Mc8d1+imrsWx3XRJ95PRKYs/hR1p9upNC0FbNzCZ19k=; b=rY7j2j6fTLIDwcO4SV6/+ijbuYydrbM9D5siBjS2GP0X/v8Hy0N3Euddl0yn0wWucC/YenQiGgZE4ftPY0PxhOpfgq9K4PQuKYixBUSiMcsbofzKyovNuA4nMbLxRNtbBWQBtI7UqeAW1nGUEWn81PeN+5VIgaiDOADhumMS54A= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=epfl.ch; Message-ID: <11fbe855-37cb-4703-b143-66563b881a4e@epfl.ch> Date: Mon, 2 Mar 2026 14:59:12 +0100 User-Agent: Mozilla Thunderbird Subject: [PATCH v5 4/7] tests/tcg: add test for qemu_plugin_set_pc API From: Florian Hofhammer To: qemu-devel@nongnu.org Cc: alex.bennee@linaro.org, pierrick.bouvier@linaro.org, richard.henderson@linaro.org, laurent@vivier.eu, imp@bsdimp.com, berrange@redhat.com References: <1739da2c-2ea6-4bc7-be6f-981f8658ce3f@epfl.ch> Content-Language: en-US Autocrypt: addr=florian.hofhammer@epfl.ch; keydata= xsFNBFw7TEkBEADaJzHcW02rDYHgS2X2kjyXLs99tnNpww/r3MlWEkrKxgfgIRbtVQTJ2vNw mxIhJnAo/Ltu2VoEXU1WGwoMGv8wxquIuE1RBnYghnYPFd4SOMX8fXz5JylHpl+vPCWiP8U0 fFWfVL1vyldQG4aVtufaJ1VEOU8zsw6YeXzxWJJ7ppUag4teMKuFya69tEEN74KLkDMJRxGk pj7rHW8Y+xBdNW9hQ2vAXhWAtm64NtCtJcJYP8RNl/jqlqYTP1Voj7byXym9HUM7NGEbGtrw 4KKi9ws1yZv9BkW3ECBg5Q1w3WYmHfwqSa+8vrD2ahNieDYNu7veYP0oMaohumRgVhiaMscD IY8wqyt6K93RiwXDQjDAqwE44xrZDr4jjCUAm1D/7WYZWtzhsiDq80JasMbXd8SLKGr96zX5 6vJGxa6OvyavRO7Y7DGK/dNPWdZqAC4QlluibdRsbkFLtBg8d60sVxYW8A9o46rrQB8qzglc joPhDebr8/NsI0gnzjgpgmNbresqne4/JIylUuJEwYcOWZqKqDw9U03uTFk/Vp6AxmRquWpy XZJVBsMNbunclgSelZIt2nzCa2nXR5MYyV2Y8ays+gSAPeHFOc6a8JWNLhgVKUed12XVrMUQ bmMmTFWWqfrx89Up4a+jW7uGIzexOeXUXKeE1j0uGsRLk6CF7QARAQABzTRGbG9yaWFuIEhv ZmhhbW1lciAoRVBGTCkgPGZsb3JpYW4uaG9maGFtbWVyQGVwZmwuY2g+wsGUBBMBCAA+AhsD BQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAFiEEqCB8P0q+u+2bTfhJlusnujFfx3wFAmfOq/AF CQ10kyEACgkQlusnujFfx3wl9Q//cNbHsBz6YvTzzi3fddVVYnEn7YBPMAw0r4vxtYpLCvpD sKOfMaGYYoV3AbVton2w53qTFcmTC/7J0/UxIi/cH1sWgVipZuVNrtESZFhkKAKpqJvHamPl uDD0kmINzztgNZOz44iUdGkSvqQW6ou5WpSEk9YEks4KPs/EH00l7hQ8YkfR/8oN63OxpYri W4+obeU45fBPPgOO1U1eMtWp/QBvo2qw+GiRQkq8kjKDTt9AYYPfcA+AdnhocgrQ2SdtcBuZ bb1BQnKEqWM2gVpvk/ujyZZktgBvqtoubAwaMpAGNgCoDju/zPf8wtbc/yo+AT+iiRQKuilm mQ7U0THfk3+DewN9CTZUiL1X6NdoUuLMqdSI4HCpo/d/N59wMkRKXHG2h/pKmTLbrHGFA4ZY a4zNN98yyPcq6OeAqurWbotXm7yxraXKkFD5dbBJcZYc5gJx+rZg2pIy+rYtQKqZWJTZhl2s ZrHNl1b8cEyS8vuiSZPjFnzgzVoBS1QE136ke/6P3rFPR4zPLyhZqKbCsGHR/BDfSCzeRwoE zJ3aV/8kmuyAfx1iTWVBLKJsPkiNS08jf+Nb+leo8Vab7AnolDTIr0o06bWas1AsIRG31/Zs wBRDlfjmKZ08f+B6a1SpkhdltGozljNt1PLEposY19aw5Ou3bqFQkYtooTfnZPnOwU0EXgiz 6wEQAM8iX+Y1mi1l3h876YmnuP8JSO1s6k0lABDO42pZaSp6Q9mFOabB7To80q1qEXCznlcR nExrN29WwXkfL2tcV4t/JFb0o4+6J9MmMUR3kdvRu55b/AGncNj0oggZDP8e5cLikv8v1ReV c//RPKSHVKnlmC9gtM0UHWpwHyyoplHi4sMJ8WyzGKfnN1eg7HlSx0xJAE7wKQP59mIMMj7n IXnk7bnGO7oaqy+i2vAxcdJPN6jvFgFCsKECL4NJCw6ifrY05paYRXza8JVwAcCzw0Sx4gZi JXC+gE4p80qNRrwR5AQuyLQNO9EfKLdnKg/85ag7xjB3ZWYMZNbj7HwCB+T16jOS+6lgGONf vctIp+hTFxXoCEnMx96FydDkqaBBjAU0JkbxhpMWFhzKzEILa60fxDxOSYHSs6h3bLk3D+gO i8j1SUPC4Olj9od7VIZDKGLd/nLw5qSt2c0H69cW1M/KS5zVARZQPb8Cqa9SAWdjmGw6MHvc WoYK4mT1arhwUlmrqUMcNqA+foGjDGPsxCQxqqIU2rB590n2wafu65UuyPUmzxOGdcb31I4E kkoBnM6G5nN4uZUCQPXl/DFlq/cfFI7LmIL2aZt6idehfvd+iOND4HDjRzrYDhz1FQn2Ihoi qHNMO4zSpWv35fl5kHfo1iYojwcd/aiyu4V8wo7TABEBAAHCwXwEGAEIACYCGwwWIQSoIHw/ Sr677ZtN+EmW6ye6MV/HfAUCZ86rzQUJC6crYgAKCRCW6ye6MV/HfK3jEACTixlDX+Xa53/f RS4AgdiLLcPnp63HYSe58cul/U8mGfcP8/wZXkPFzpsQZRONmj0vNHFAlTlQHpBnMmqxUvVx SosHPMrSwukjV/zDgTeYe8iZbqDjUEFIJvEU4mQd1O2/bfBCi0N0GuleN+oyu4cHhgJIN/Ym 3yJks/Aeprt4k3YwTZsGRCQ4fVyfmnHyYGLNKjtR/ubibG1I4hDVhf1IwrvsAcpHw1UKf/5+ ZA3O6ZANAwVG2iAidR2LhFPiBAFWtPmI0dX5i8+Hu5CmXlHkYK2TV8ys9zDuOEiWEcMR/9tA agcgw3orjj0lvFiSGYI9+w1NxO76T/by09nWsLXr8Mas+pFaKUP0Wk9vZjj+8TqPTkoKOMJS /+vsAGjFLM1ZfFyLRvVVJH4gaWs5zie533zYlArVA1db36+YGTBWzuHEawITPaLq/FngWb+e bxL9a5LkhEdTCnQVhBaC0yBbplRQcGwsc8IRK0sdWiRIGtlr6NMt1yw+3TwVsBPaYvLM/qfm pBZkz7hBNr2qTLcl1xeP4MMdMO2ubBUGTR5B+sOzaT1qIBe5XNFkhffLTR+YmkW1PXWz7tcO yQcudEYHvYhKegsw0Zjv8iQIQw3yeV0WbQAs+LGQAfwpVURhZgBk3DH9gQBFkZYi8YWX/zEc 5hMMZIzTI4AtIcgA3xe4Ew== In-Reply-To: <1739da2c-2ea6-4bc7-be6f-981f8658ce3f@epfl.ch> Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: GV0P278CA0090.CHEP278.PROD.OUTLOOK.COM (2603:10a6:710:2b::23) To ZRH2PFAD84B9AF9.CHEP278.PROD.OUTLOOK.COM (2603:10a6:918::220) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: ZRH2PFAD84B9AF9:EE_|GV0P278MB1029:EE_ X-MS-Office365-Filtering-Correlation-Id: fc0ffe07-d158-4dcf-4b74-08de7864864a X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230040|376014|786006|366016|1800799024|19092799006; X-Microsoft-Antispam-Message-Info: 0hAJERx++uYF6NOw6fUGzk+tSwJ+1+172M9ytZFYYcJ8Wlcno7wr8pgJ6u5XP5lVX15b4tlZv+Z48LqzopY6lJUdxd1WYSYGI+a8n60ghbeAiDGpptZwydt7mQG8e2vAXiLOynRi6ROPJNuH9WXotMxNa4EJSo0cakF580YUoXdXUqMGW1fyGArPik8aDWnnkmckIzPVdxheEPWLfGsFm5fQkZAkgl1JAzRYbRgNrumPvySTtQtp7elNRbxCZONP1VngXBZGpU7JkUbCH8tFCjxDB/+I5W5JvmYCSX/7JgZE1iPAm9mmiys1OhImt4weig3EamCMaTfusgiUF7lim4kUoHsrtQwsePmwYHXOht995fyn5KwduuEHwM8wb9gl6/COAWT7WeJylYc0YcHovvlnX/1sEA9wo1WlQsuzojYi21ez2IShPNg4Qdn6skj6/N8JbZS0fekw6y8tMR8+DDVsP3bn1QBFEHLPeZ27KMpb8mMIYANcKxCh6Pzlmmluc7IXfy7MLpvGU2IH6XaYkO8Rdpoc9We+lKYVrDVyw34s4VkTY0ijp0+J+W+ImropWbxuqvhWJITDIUgy6xKkqtlCUyGKsQd9Dbvrp1BZklCe1reWn5XZ0XBRspoSVvOn74vVJWaRZ5zQ8YXYtCeJG9h2aT6mbRF7mQsfUK7BR4pAlkm66nRyFpzYA1PCCRg40gU807op4VM8n4YypNhkz0LrGFxnv3smVAmre5HtJ2s= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:ZRH2PFAD84B9AF9.CHEP278.PROD.OUTLOOK.COM; PTR:; CAT:NONE; SFS:(13230040)(376014)(786006)(366016)(1800799024)(19092799006); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?cEFwa1JUVEsrcDcvcm5oNHN2M0RNUGh3dytaaGtrMUZpcmpadTBNVjlIYWJM?= =?utf-8?B?MFRLNEF4Q1o0d3Y1bHRtNHp6VTZSS2RGc2FPRDdmS1cxenBtNGRBd0E4Sy9v?= =?utf-8?B?YU5sbkZ1bC9GbGF2ZU16ei8zbDFsZXFISEQ1S0RvbU9Kc2YzZHZER3BDOEd2?= =?utf-8?B?dVlmUjZ2SkFNVitLcFdSd044MWlHTUZIVjdzUGRpQzRkUGxhTW5ZRVBRUnc2?= =?utf-8?B?OThpT0U4RXBxVVpYNG5BbUhHLzltbUJsMUZMN1R3dklXdVlhcUlkVGNzQ2JC?= =?utf-8?B?VUQ0ZUNNeERBNlVmRVdvbG45U0c2d2FhTmwzaldYODVudkFzdmFmMjB4alU5?= =?utf-8?B?aVdUZHVmcDdvL1VUZ1lOWHUxNDNCS25IdEVjNmk0UldaUndJY2tDdFY5aVFS?= =?utf-8?B?a3JvRGtnTU5PdzVpZVJPalNsbU11ZUxWc1RZTDhiZnBIdUh3cGNRSDFudE91?= =?utf-8?B?czRxWHZtQ1pyem9qU1JVcFpmcyt1emRUdmxhaVp5TlFyLzdpeUF3TFZLN3pB?= =?utf-8?B?M29HcE5CVlJFNEhLOFFMZmRqZlByNC8rYWU2TnF0elMzVytYTjkrdkkzb1pS?= =?utf-8?B?T3ZhQWhzTGtJQWljZkhUTWtJTGtBNlU2UXJOMWJaTE85QnBoRzJ6Zks3bUE2?= =?utf-8?B?MnpiQjZ4VWhmdVFPUm9sL0ZPQ2JsWVhCaUVnM0ZoNVpncUxtYW9FbkRWVTFE?= =?utf-8?B?ZW0zb1dPenpuWTdIeXNDcFdSSGlYalI5RXJGZXA0WVQ2UDZiR2pBSWhoMmV5?= =?utf-8?B?elhOaTZSZTBnWVpUcVFhRUpBVlFmV3lORWFvWjZEU0xJTUZBVjJHZ2M3SDFt?= =?utf-8?B?M0dBSXA0RHFYNlBtajFmSjRFeG1HKzlOWEtZMW1ZcWJGbGlMSFdxLzJPYWpY?= =?utf-8?B?c0RHRGRTWnhwRllZSExxNTVDNHVSOXo5OHFjdEs4cWdSajZ1WjIzYi9CNm8z?= =?utf-8?B?Rlcwd2Y4S2xEZnBqQ1l4WHhtQ1hlYnhVNDFUUHRPd0F5ZVhCY2l2SWNHOWRh?= =?utf-8?B?VlRNV2JqdFN1d2RUcHl1clVmL051TEFhVEo4MEtaa1FaNFZ5cUdabnBKdWQ4?= =?utf-8?B?eXRUMTgxYk9BcklvZTlQcFp4U0ZBZFVGUmdrL1NqZHozUUcvdHZaZExFUlNX?= =?utf-8?B?SENyNGRMYmtDVmpRMWVzZHFTWDZOczVDMEdTeFh5WC9KK3M4YVpaNVFLeUZG?= =?utf-8?B?UEtrTUdxdXhsUFdTc0ZDb3duU3Vmb2pROThYUmE0VGdjcUc0UVNFbTFKZ2lu?= =?utf-8?B?Y2RBdWhzSkt0eTlGdGtTdVVpR1lWVEswZFJTd3hIREwvUXVnWmwvVTI4ZUlk?= =?utf-8?B?RXNuNStNeC9GQ3F6QTFCSHJqbFk1MW9vNmdvTGcxZFp3aFYrM0dWVlRqZW5R?= =?utf-8?B?TVdBODJQU2dXMW82OGNFcWRCNUh2TGk1YWUwdzExMnFmY2FoRDhyUjhPbmZ6?= =?utf-8?B?dWMxNGZDQmlQYUxJOE1pSGdPZXdqN0VhU3Y3WVczVHRETnVxMmhaOE5ZcFJK?= =?utf-8?B?Smp5ODJLcnZnUWxCQkZsKzdFc1BydnExeXAxR1FyTEh5bnBpdVRTRUdVVkt1?= =?utf-8?B?WGxscUUvd2doRVhkbVpWL0pBMXIrRXdEandxOWZqUy96NHd3U0ZVSVhQR2NT?= =?utf-8?B?YnN2WHhNaCtPNG4xOHlFUDQ0aGxTa2RGcG9nczJNbnhJM1BwY1duNGhCdmlW?= =?utf-8?B?SzduZEpqU0tWQ0pnOEtSVWZXMW04L08vRWtPbldVRUs5enJkcXNYSkdaR3Z5?= =?utf-8?B?NVN0OUI0aU5vbjBUS2ZpUmt2aDNkQXZuRlc1RUhKR0pFNDhhMmV3NUZZdVI4?= =?utf-8?B?REJ0TXJqcVVLTm93cFczelhIeFBFQnkzL2FkUWVTRWs5MWVxc2wxNEZkRTIr?= =?utf-8?B?bzhCZzMxamtZZ1VtcnlETmpLTkhPZm9CbTRQSnY0cFZlY2dvclUwQmkyOVlJ?= =?utf-8?B?TkhsL0xoVGVRNVFqbk9TcUs3OFdoV0lITzBEYzBtZm1BdDM1QmhpRDZCTits?= =?utf-8?B?RUhxUDg4bW1seGJLS2puZEo5VnBwd0ZTcno0U2hEZnRSSXNkbktmMFM1WXUy?= =?utf-8?B?YVI2M0xIQml2U2ZOTW8rZFVLZ3hFWkpFdiszMHduS3dqSmhnTVA4bjRVam9k?= =?utf-8?B?ck42WnlwMHlIaXJlZ2l4dkFVeWhyRFJuaThkY0RXUnQ2ZjZZY29NTkNjZTRN?= =?utf-8?B?OW1LdkVKek1kMXFvOGxUaDZPcEgvdFZTa0lqQzVCTTUxMVNXemY5TEVFejJv?= =?utf-8?B?RlRydDNiY2xjQVlVaS9Xc2g3elpEbHJWdVZwVXU3dFZoTDlpcmhMYWQ5Vko0?= =?utf-8?B?eDBLVU10ckc5RE5UTFNabEphNHhiNENlUkJkOGtqVHZETGhYUXl6Zz09?= X-OriginatorOrg: epfl.ch X-MS-Exchange-CrossTenant-Network-Message-Id: fc0ffe07-d158-4dcf-4b74-08de7864864a X-MS-Exchange-CrossTenant-AuthSource: ZRH2PFAD84B9AF9.CHEP278.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Mar 2026 14:03:47.9553 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: f6c2556a-c4fb-4ab1-a2c7-9e220df11c43 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: UzopiO3fKqzZILRlz+Ve4Kw8FkYPrdLtNtiZXPDB5Nfy6iYr87/9ROz1tKKAeuvqHt7j60Yf+FKFblfSmes3ekj1SOODLQY3tmVvPYinUkQ= X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV0P278MB1029 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a01:111:f403:c214::1; envelope-from=florian.hofhammer@epfl.ch; helo=GVAP278CU002.outbound.protection.outlook.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @epfl.ch) X-ZM-MESSAGEID: 1772460343697158500 Content-Type: text/plain; charset="utf-8" The test executes a non-existent syscall, which the syscall plugin intercepts and redirects to a clean exit. Due to architecture-specific quirks, the architecture-specific Makefiles require setting specific compiler and linker flags in some cases. Signed-off-by: Florian Hofhammer --- MAINTAINERS | 1 + tests/tcg/arm/Makefile.target | 6 + tests/tcg/multiarch/Makefile.target | 17 ++- .../{ =3D> plugin}/check-plugin-output.sh | 0 .../{ =3D> plugin}/test-plugin-mem-access.c | 0 .../tcg/multiarch/plugin/test-plugin-set-pc.c | 140 ++++++++++++++++++ tests/tcg/plugins/meson.build | 1 + tests/tcg/plugins/setpc.c | 120 +++++++++++++++ 8 files changed, 282 insertions(+), 3 deletions(-) rename tests/tcg/multiarch/{ =3D> plugin}/check-plugin-output.sh (100%) rename tests/tcg/multiarch/{ =3D> plugin}/test-plugin-mem-access.c (100%) create mode 100644 tests/tcg/multiarch/plugin/test-plugin-set-pc.c create mode 100644 tests/tcg/plugins/setpc.c diff --git a/MAINTAINERS b/MAINTAINERS index 606b16762c..2746ec9a0b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4083,6 +4083,7 @@ S: Maintained F: docs/devel/tcg-plugins.rst F: plugins/ F: tests/tcg/plugins/ +F: tests/tcg/multiarch/plugin/ F: tests/functional/aarch64/test_tcg_plugins.py F: contrib/plugins/ F: scripts/qemu-plugin-symbols.py diff --git a/tests/tcg/arm/Makefile.target b/tests/tcg/arm/Makefile.target index 6189d7a0e2..613bbf0939 100644 --- a/tests/tcg/arm/Makefile.target +++ b/tests/tcg/arm/Makefile.target @@ -78,4 +78,10 @@ sha512-vector: sha512.c =20 ARM_TESTS +=3D sha512-vector =20 +ifeq ($(CONFIG_PLUGIN),y) +# Require emitting arm32 instructions, otherwise the vCPU might accidental= ly +# try to execute Thumb instructions in arm32 mode after qemu_plugin_set_pc= () +test-plugin-set-pc: CFLAGS+=3D-marm +endif + TESTS +=3D $(ARM_TESTS) diff --git a/tests/tcg/multiarch/Makefile.target b/tests/tcg/multiarch/Make= file.target index 07d0b27bdd..a347efbadf 100644 --- a/tests/tcg/multiarch/Makefile.target +++ b/tests/tcg/multiarch/Makefile.target @@ -14,6 +14,10 @@ ifeq ($(filter %-linux-user, $(TARGET)),$(TARGET)) VPATH +=3D $(MULTIARCH_SRC)/linux MULTIARCH_SRCS +=3D $(notdir $(wildcard $(MULTIARCH_SRC)/linux/*.c)) endif +ifeq ($(CONFIG_PLUGIN),y) +VPATH +=3D $(MULTIARCH_SRC)/plugin +MULTIARCH_SRCS +=3D $(notdir $(wildcard $(MULTIARCH_SRC)/plugin/*.c)) +endif MULTIARCH_TESTS =3D $(MULTIARCH_SRCS:.c=3D) =20 # @@ -200,13 +204,20 @@ run-plugin-test-plugin-mem-access-with-libmem.so: \ PLUGIN_ARGS=3D$(COMMA)print-accesses=3Dtrue run-plugin-test-plugin-mem-access-with-libmem.so: \ CHECK_PLUGIN_OUTPUT_COMMAND=3D \ - $(SRC_PATH)/tests/tcg/multiarch/check-plugin-output.sh \ + $(SRC_PATH)/tests/tcg/multiarch/plugin/check-plugin-output.sh \ $(QEMU) $< run-plugin-test-plugin-syscall-filter-with-libsyscall.so: +run-plugin-test-plugin-set-pc-with-libsetpc.so: =20 EXTRA_RUNS_WITH_PLUGIN +=3D run-plugin-test-plugin-mem-access-with-libmem.= so \ - run-plugin-test-plugin-syscall-filter-with-libsyscall.so -else + run-plugin-test-plugin-syscall-filter-with-libsyscall.so \ + run-plugin-test-plugin-set-pc-with-libsetpc.so + +else # CONFIG_PLUGIN=3Dn +# Do not build the syscall skipping test if it's not tested with the setpc +# plugin because it will simply fail the test. +MULTIARCH_TESTS :=3D $(filter-out test-plugin-set-pc, $(MULTIARCH_TESTS)) + # test-plugin-syscall-filter needs syscall plugin to succeed test-plugin-syscall-filter: CFLAGS+=3D-DSKIP endif diff --git a/tests/tcg/multiarch/check-plugin-output.sh b/tests/tcg/multiar= ch/plugin/check-plugin-output.sh similarity index 100% rename from tests/tcg/multiarch/check-plugin-output.sh rename to tests/tcg/multiarch/plugin/check-plugin-output.sh diff --git a/tests/tcg/multiarch/test-plugin-mem-access.c b/tests/tcg/multi= arch/plugin/test-plugin-mem-access.c similarity index 100% rename from tests/tcg/multiarch/test-plugin-mem-access.c rename to tests/tcg/multiarch/plugin/test-plugin-mem-access.c diff --git a/tests/tcg/multiarch/plugin/test-plugin-set-pc.c b/tests/tcg/mu= ltiarch/plugin/test-plugin-set-pc.c new file mode 100644 index 0000000000..40d9a9e8f0 --- /dev/null +++ b/tests/tcg/multiarch/plugin/test-plugin-set-pc.c @@ -0,0 +1,140 @@ +/* + * SPDX-License-Identifier: GPL-2.0-or-later + * + * Copyright (C) 2026, Florian Hofhammer + * + * This test set exercises the qemu_plugin_set_pc() function in four diffe= rent + * contexts: + * 1. in a syscall callback, + * 2. in an instruction callback during normal execution, + * 3. in an instruction callback during signal handling, + * 4. in a memory access callback. + * Note: using the volatile guards is necessary to prevent the compiler fr= om + * doing dead code elimination even on -O0, which would cause everything a= fter + * the asserts and thus also the target labels to be optimized away. + */ +#include +#include +#include +#include +#include +#include +#include + +#define NOINLINE __attribute__((noinline)) +#define NORETURN __attribute__((noreturn)) + +static int signal_handled; +/* + * The volatile variable is used as a guard to prevent the compiler from + * optimizing away "unreachable" labels. + */ +static volatile uint32_t guard =3D 1; + +/* + * This test executes a magic syscall which communicates two addresses to = the + * plugin via the syscall arguments. Whenever we reach the "bad" instructi= on + * during normal execution, the plugin should redirect control flow to the + * "good" instruction instead. + */ +NOINLINE void test_insn(void) +{ + long ret =3D syscall(4095, &&bad_insn, &&good_insn, NULL); + assert(ret =3D=3D 0 && "Syscall filter did not return expected value"); + if (guard) { +bad_insn: + assert(0 && "PC redirection in instruction callback failed"); + } else { +good_insn: + return; + } +} + +/* + * This signal handler communicates a "bad" and a "good" address to the pl= ugin + * similar to the previous test, and skips to the "good" address when the = "bad" + * one is reached. This serves to test whether PC redirection via + * qemu_plugin_set_pc() also works properly in a signal handler context. + */ +NOINLINE void usr1_handler(int signum) +{ + long ret =3D syscall(4095, &&bad_signal, &&good_signal, NULL); + assert(ret =3D=3D 0 && "Syscall filter did not return expected value"); + if (guard) { +bad_signal: + assert(0 && "PC redirection in instruction callback failed"); + } else { +good_signal: + signal_handled =3D 1; + return; + } +} + +/* + * This test sends a signal to the process, which should trigger the above + * signal handler. The signal handler should then exercise the PC redirect= ion + * functionality in the context of a signal handler, which behaves a bit + * differently from normal execution. + */ +NOINLINE void test_sighandler(void) +{ + struct sigaction sa =3D {0}; + sa.sa_handler =3D usr1_handler; + sigaction(SIGUSR1, &sa, NULL); + pid_t pid =3D getpid(); + kill(pid, SIGUSR1); + assert(signal_handled =3D=3D 1 && "Signal handler was not executed pro= perly"); +} + +/* + * This test communicates a "good" address and the address of a local vari= able + * to the plugin. Upon accessing the local variable, the plugin should then + * redirect control flow to the "good" address via qemu_plugin_set_pc(). + */ +NOINLINE void test_mem(void) +{ + long ret =3D syscall(4095, NULL, &&good_mem, &guard); + assert(ret =3D=3D 0 && "Syscall filter did not return expected value"); + if (guard) { + assert(0 && "PC redirection in memory access callback failed"); + } else { +good_mem: + return; + } +} + +/* + * This test executes a magic syscall which is intercepted and its actual + * execution skipped via the qemu_plugin_set_pc() API. In a proper plugin, + * syscall skipping would rather be implemented via the syscall filtering + * callback, but we want to make sure qemu_plugin_set_pc() works in differ= ent + * contexts. + */ +NOINLINE NORETURN +void test_syscall(void) +{ + syscall(4096, &&good_syscall); + if (guard) { + assert(0 && "PC redirection in syscall callback failed"); + } else { +good_syscall: + /* + * Note: we execute this test last and exit straight from here bec= ause + * when the plugin redirects control flow upon syscall, the stack = frame + * for the syscall function (and potential other functions in the = call + * chain in libc) is still live and the stack is not unwound prope= rly. + * Thus, returning from here is risky and breaks on some architect= ures, + * so we just exit directly from this test. + */ + _exit(EXIT_SUCCESS); + } +} + + +int main(int argc, char *argv[]) +{ + test_insn(); + test_sighandler(); + test_mem(); + test_syscall(); +} diff --git a/tests/tcg/plugins/meson.build b/tests/tcg/plugins/meson.build index c5e49753fd..b3e3a9a6d0 100644 --- a/tests/tcg/plugins/meson.build +++ b/tests/tcg/plugins/meson.build @@ -7,6 +7,7 @@ test_plugins =3D [ 'mem.c', 'patch.c', 'reset.c', +'setpc.c', 'syscall.c', ] =20 diff --git a/tests/tcg/plugins/setpc.c b/tests/tcg/plugins/setpc.c new file mode 100644 index 0000000000..72ae31a0ef --- /dev/null +++ b/tests/tcg/plugins/setpc.c @@ -0,0 +1,120 @@ +/* + * SPDX-License-Identifier: GPL-2.0-or-later + * + * Copyright (C) 2026, Florian Hofhammer + */ +#include +#include +#include +#include + +#include + +QEMU_PLUGIN_EXPORT int qemu_plugin_version =3D QEMU_PLUGIN_VERSION; + +static uint64_t source_pc; +static uint64_t target_pc; +static uint64_t target_vaddr; + +static void vcpu_syscall(qemu_plugin_id_t id, unsigned int vcpu_index, + int64_t num, uint64_t a1, uint64_t a2, + uint64_t a3, uint64_t a4, uint64_t a5, + uint64_t a6, uint64_t a7, uint64_t a8) +{ + if (num =3D=3D 4096) { + qemu_plugin_outs("Marker syscall detected, jump to clean return\n"= ); + qemu_plugin_set_pc(a1); + } +} + +static bool vcpu_syscall_filter(qemu_plugin_id_t id, unsigned int vcpu_ind= ex, + int64_t num, uint64_t a1, uint64_t a2, + uint64_t a3, uint64_t a4, uint64_t a5, + uint64_t a6, uint64_t a7, uint64_t a8, + uint64_t *sysret) +{ + if (num =3D=3D 4095) { + qemu_plugin_outs("Communication syscall detected, set target_pc / " + "target_vaddr\n"); + source_pc =3D a1; + target_pc =3D a2; + target_vaddr =3D a3; + if (source_pc >> 63 || target_pc >> 63 || target_vaddr >> 63) { + /* + * Some architectures (e.g., m68k) use 32-bit addresses with t= he + * top bit set, which causes them to get sign-extended somewhe= re in + * the chain to this callback. We mask the top bits off here t= o get + * the actual addresses. + */ + qemu_plugin_outs("High bit in addresses detected: possible sig= n " + "extension in syscall, masking off top bits\n= "); + source_pc &=3D UINT32_MAX; + target_pc &=3D UINT32_MAX; + target_vaddr &=3D UINT32_MAX; + } + *sysret =3D 0; + return true; + } + return false; +} + +static void vcpu_insn_exec(unsigned int vcpu_index, void *userdata) +{ + uint64_t vaddr =3D (uint64_t)userdata; + if (vaddr =3D=3D source_pc) { + g_assert(target_pc !=3D 0); + g_assert(target_vaddr =3D=3D 0); + + qemu_plugin_outs("Marker instruction detected, jump to clean retur= n\n"); + qemu_plugin_set_pc(target_pc); + } +} + +static void vcpu_mem_access(unsigned int vcpu_index, + qemu_plugin_meminfo_t info, + uint64_t vaddr, void *userdata) +{ + if (vaddr !=3D 0 && vaddr =3D=3D target_vaddr) { + g_assert(source_pc =3D=3D 0); + g_assert(target_pc !=3D 0); + qemu_plugin_mem_value val =3D qemu_plugin_mem_get_value(info); + /* target_vaddr points to our volatile guard =3D=3D> should always= be 1 */ + g_assert(val.type =3D=3D QEMU_PLUGIN_MEM_VALUE_U32); + g_assert(val.data.u32 =3D=3D 1); + + qemu_plugin_outs("Marker mem access detected, jump to clean return= \n"); + qemu_plugin_set_pc(target_pc); + } +} + +static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) +{ + size_t insns =3D qemu_plugin_tb_n_insns(tb); + for (size_t i =3D 0; i < insns; i++) { + struct qemu_plugin_insn *insn =3D qemu_plugin_tb_get_insn(tb, i); + uint64_t insn_vaddr =3D qemu_plugin_insn_vaddr(insn); + /* + * Note: we cannot only register the callbacks if the instruction = is + * in one of the functions of interest, because symbol lookup for + * filtering does not work for all architectures (e.g., ppc64). + */ + qemu_plugin_register_vcpu_insn_exec_cb(insn, vcpu_insn_exec, + QEMU_PLUGIN_CB_RW_REGS_PC, + (void *)insn_vaddr); + qemu_plugin_register_vcpu_mem_cb(insn, vcpu_mem_access, + QEMU_PLUGIN_CB_RW_REGS_PC, + QEMU_PLUGIN_MEM_R, NULL); + } +} + + +QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id, + const qemu_info_t *info, + int argc, char **argv) +{ + + qemu_plugin_register_vcpu_syscall_cb(id, vcpu_syscall); + qemu_plugin_register_vcpu_syscall_filter_cb(id, vcpu_syscall_filter); + qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans); + return 0; +} --=20 2.53.0