From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.openvz.org (mail.openvz.org [69.168.225.77]) by lore.virtuozzo.com (Postfix) with ESMTPS id E634E81989 for ; Tue, 17 Nov 2026 11:33:23 +0000 (UTC) Received: from mail.openvz.org (localhost [127.0.0.1]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AHBW8l5009112; Tue, 17 Nov 2026 14:32:09 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AHBW8l5009112 Authentication-Results: mail.openvz.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=virtuozzo.com header.i=@virtuozzo.com header.b="L04zYVlT" Received: from mail-pj1-f69.google.com (mail-pj1-f69.google.com [209.85.216.69]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AHBW6Ju009108 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=FAIL) for ; Tue, 17 Nov 2026 14:32:07 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AHBW6Ju009108 Received: by mail-pj1-f69.google.com with SMTP id 98e67ed59e1d1-3b0c7ab2427so3676514a91.1 for ; Tue, 17 Nov 2026 03:32:07 -0800 (PST) X-Forwarded-Encrypted: i=3; AL+hErGEtOvuIyH26oSPB0zKfAzJL40ZVlGULbroBlC9T5cCYpT8yg5aYBxX1ilGOp/vAihd2dXJhw==@openvz.org X-Gm-Message-State: APuU4Z+0Y6sLXGZEXl81NfTk4P3vKbrsNMxn4rGZKlFknF3yxTer2j9S ANU/zLj+uq0ykb1kPJTV3aAliCdODMpmdIIwLlI3G0QFaR4z/Cdlbl+mNRGfNauu1w8XaXd/3ve xApyi3hT//1HrYBeULvsf1xtSIqWfad3CN9naUOdHiVGmBQvYKN5cnw== X-Gm-Gg: AZFdTZeVSG/MidRZ0T6KZ+IaEJuav8f4j5fXoUdXoGFNGh/5kXCnbrXwqe+/bdRNORh 93n58usNH6yzT04j+LXQr6H7IdFLSI4G+hz7R7s+e5Mr/cMNCteNt/P6In3vP0OVMNXblgjlwEj fUsgeZZMrYaW16HfDmD8Prf0xbQzzsgyzIqMYWZrRV7bhgH5Gnqx6/YmsiFd1tu56S9i3F47SoE FDktv2Na9G5l64DPmnyr/ugvT8qUQimYfDkxS3L6ygqpaez+kmZ+tIInDHwpJ+XAOjNxQnY1EM9 ZamlSWMceOE+q6qPZowbk1qMONIohSZc4Kx/DtMkmcpNOTgZQreLjXcPwlpJDli3ZLX0LbfPJK8 FiZp5roifylUwgOMEuMFH75r0WvlWs2K9SARnggpcaNuDqWb4h0jd9Lzf1YCNNVF2BZKz9NSSlq sNzPScBppyYUQrIst8geWF4iSX2qSDgVhI3pOX X-Received: by 2002:a17:90b:4b01:b0:3b0:abb7:3fdc with SMTP id 98e67ed59e1d1-3b1b0b94ecbmr13765064a91.60.1794915126004; Tue, 17 Nov 2026 03:32:06 -0800 (PST) X-Received: by 2002:a17:90b:4b01:b0:3b0:abb7:3fdc with SMTP id 98e67ed59e1d1-3b1b0b94ecbmr13765046a91.60.1794915125316; Tue, 17 Nov 2026 03:32:05 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1794915125; cv=pass; d=google.com; s=arc-20260327; b=Zqr1322nbbC6JRDuBaWNjV4/IqLJp5J47HfdVFi3ShLXyVV4V9a2BSW4odM9xWGea5 AbnYRXCBNhpAUn+9RgBUDMCRW+Bec3u48tWhJQ0XMrd28P5fyQLJoQXM2h333pR2DgL2 iSTVFURp9xUU0CZCRmranzUbm+H60TvULgYPj5XloBTo1Kc+oXYjHkO3Yz40phYYAMND YtTAanlEltIt3rrPr50Au9l0YQOWCbN19NZ6ScBxXy0ypQuYPGjwgHzyY6qFSfEB9kL1 d49/FPH476jylwbVhAXHC7HkxMiADtVliDp4VFV1OPdHhBAnkyDcaHtlHcNt0zOf6H07 G/RA== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20260327; h=mime-version:content-transfer-encoding:in-reply-to:from :content-language:references:cc:to:subject:user-agent:date :message-id:dkim-signature; bh=4SO/8rYUejqDL9TjpSe8ItYHsQ+I0QyVh0TLtqEQxrA=; fh=NQShvAamTRhKeEdBP+VGPvHYs3WDIRdtFLGEhdoHFRg=; b=N7AnreUjxIbvsFFu2INhZyVMHijkKnGYb4uc+8dcZNM3tbLXtpszb7i0GdkiiVmze5 caXyWB4HJSuh2dso9Iq71ZNWUSTbO4shrOMY7UEhzhowgwY1N22iYAI5nOKjfXaJ1gV4 5t0XzNqMJXntG/HcI4s9S6l9HH5nhpQWrMp8+2OMOp6py5XggIT8wEzNoSzbLfiXLK9o tZCus7ncbMy6GsM+RFDsSWRQACFoUsQogPZTZbtUrVYAZNoUDX2buzPNMCXJJvCCDQdZ Lyrh44CHHENtNjjlZkQGgnDhtTchvFlStdvWikW26WPrF0b/HPmyRpkRxO2BcEs9UkO/ J6cg==; dara=google.com ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=selector2 header.b=L04zYVlT; arc=pass (i=1 spf=pass spfdomain=virtuozzo.com dkim=pass dkdomain=virtuozzo.com dmarc=pass fromdomain=virtuozzo.com); spf=pass (google.com: domain of andrey.zhadchenko@virtuozzo.com designates 2a01:111:f403:c200::1 as permitted sender) smtp.mailfrom=andrey.zhadchenko@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com Received: from DB3PR0202CU003.outbound.protection.outlook.com (mail-northeuropeazlp170100001.outbound.protection.outlook.com. [2a01:111:f403:c200::1]) by mx.google.com with ESMTPS id 41be03b00d2f7-cddc4c23c61si17959818a12.303.2026.11.17.03.32.04 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 17 Nov 2026 03:32:05 -0800 (PST) Received-SPF: pass (google.com: domain of andrey.zhadchenko@virtuozzo.com designates 2a01:111:f403:c200::1 as permitted sender) client-ip=2a01:111:f403:c200::1; Authentication-Results: mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=selector2 header.b=L04zYVlT; arc=pass (i=1 spf=pass spfdomain=virtuozzo.com dkim=pass dkdomain=virtuozzo.com dmarc=pass fromdomain=virtuozzo.com); spf=pass (google.com: domain of andrey.zhadchenko@virtuozzo.com designates 2a01:111:f403:c200::1 as permitted sender) smtp.mailfrom=andrey.zhadchenko@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=JX43y3nI9bbrskwjL8XFZhdGD5kJcAlU2j2AD0zjFmzgmcjV3vP/A/GLYLPqnCVw522Eok5ZsapUGG1cU50Lz2ldayyfoB7qrmtuKOB0DtAeuklJ2DwlecCEUh0EuPpVSbm2sa+IGpb4vqdXVJkhJ6SI4Q52lQ4blxk1yscPgaY/A3nhJvo18r/OQ7EZjAxpM48AvRsBT9ejGQ5ay3d8QrFNkN5AhEKvb8jvG4ct/jpYys/IncfV2YTvfSyGq+qxgxh4iUxKEYOqXfcW/wdERzx+47jHAMrROSvMAyDCSupMU8iyJZye898N/FEk5TiyX7zVHbFcrv0k3tiyuSvEpg== 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=4SO/8rYUejqDL9TjpSe8ItYHsQ+I0QyVh0TLtqEQxrA=; b=eJdW2YPEjYGiYL2sUtzJBwAEEq9tka3ZAXWcoN4s/zlJ616x4YKB54XhfnerU7bj7nusi3J9ShUNU0w1fFLd/Gr+Yj6JCwcCq5Ptg7eBbImJxJbOioZyQB7EbVSe3wmzRIZN51ePQKXlg7uxcDnD16AAqlGKevQ8iJ5ZtvjU8Iq9oG9PaZS7jS544/8GTJHd0mpecI+nzQkgk5iLGt3o4DI3pOe/Al2oMxW6POUVKq0SHeGjmu/NEl4lcI3fA4ruIEfe73mX/JhBA/inB42B917+JYOfwu41noSaCTgvxWVd0jes5HTIeRhYfgq6j5H8JufoCj630qniE+9NaUI4qA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=virtuozzo.com; dmarc=pass action=none header.from=virtuozzo.com; dkim=pass header.d=virtuozzo.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=virtuozzo.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=4SO/8rYUejqDL9TjpSe8ItYHsQ+I0QyVh0TLtqEQxrA=; b=L04zYVlTE9eNVOfBsy97fUvXjHnLW17/YjPN830OmvlgwUG3+Mom2w4YOzyr7DKfCiAKD1T4Vx9F01fa8elDUNOOsWfe67Hu8sDXxbD997BK5JTYBGpxZk0hzBZp2+c1COKr9Ed81avIoIg7X/M+rFo1z3hjl2q1J8h2Xoun9Xq24z931++YeBqQknkMBPrrHDyVnvT5TphgT1t1Q2gBcUr5lKJ0QpQeVabPXWd2ES27dR0H1cSmAH8Cmj1TjLL78jvt3FK6hkRHdSaYq30WaXmgOxrndRO9eS4lXCjTl/LqHfz9uHnv+YTAF73a5Ntfjqa9mOz9oHOnQCFUKk6lOQ== Authentication-Results: mx.microsoft.com 1; dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=virtuozzo.com; Received: from PA4PR08MB6061.eurprd08.prod.outlook.com (2603:10a6:102:e9::13) by DB9PR08MB8226.eurprd08.prod.outlook.com (2603:10a6:10:39e::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.615.14; Tue, 17 Nov 2026 11:32:01 +0000 Received: from PA4PR08MB6061.eurprd08.prod.outlook.com ([fe80::c3bf:e107:b1d2:6a00]) by PA4PR08MB6061.eurprd08.prod.outlook.com ([fe80::c3bf:e107:b1d2:6a00%4]) with mapi id 15.21.0615.013; Tue, 17 Nov 2026 11:32:01 +0000 Message-ID: Date: Tue, 17 Nov 2026 12:32:00 +0100 User-Agent: Mozilla Thunderbird To: Alexander Ivanov References: <20261117100904.3071306-1-alexander.ivanov@virtuozzo.com> <20261117100904.3071306-3-alexander.ivanov@virtuozzo.com> Content-Language: en-US From: Andrey Zhadchenko In-Reply-To: <20261117100904.3071306-3-alexander.ivanov@virtuozzo.com> X-ClientProxiedBy: FR0P281CA0245.DEUP281.PROD.OUTLOOK.COM (2603:10a6:d10:af::6) To PA4PR08MB6061.eurprd08.prod.outlook.com (2603:10a6:102:e9::13) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: PA4PR08MB6061:EE_|DB9PR08MB8226:EE_ X-MS-Office365-Filtering-Correlation-Id: 2923c0a8-3b09-4cb4-3e46-08df449e65a3 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230040|1800799024|376014|23010399003|366016|22082099003|18002099003|261009223027099003|56012099006|4143699003|261102123227099003|261028144727099003|261026140227099003|261021121427099003|261022105027099003|261026121527099003|261021123027099003|261021135927099003|10067099003; X-Microsoft-Antispam-Message-Info: wiX6/7cADSrwTyuPrz/bmikk43xE0nOe5TwcfUYtUv603mE7kK61SmcwZ0s666/yZXXACHN6tSlCkXZ902vI5S6BAoTwQcfEEHrvGfkXt60nMnTGsE3D0f0VIrGF4nIuc/RLkn9PLGlbmCieqCPvNnBVi70Bce2Y4/XbSx+xxIEZC7LLadoYwfBXnFslgoOE74plrYW/B1V8eQIoyjNB7JeYc3bA7qAlr1GtaVlN09fH8k7TclLY2peZjz22q56D9MPAKmOiIkRqNphnjnMHMrAEbu1VmA30HqSfzyILTE/NG8/kt/uLGbkZCDB/c+6wTDONJyFP6jrkzxzXEut4lcs3mE6lCcHBXN+eYg6Y1Ewnbqy487GnIP5d9J54mf9bKaBxsIntc52c7324H/uYhnV+BCKXc/Ua9o8Lkm++/vM/P5gYslwmwzy/0CefahMvk/IV1aLyMUN8B4KZh7F7j4B+FjmbmGBkY7rPCPxfzcZbJbG+G+l3z5aZdlLdsXWd1K6MVaS7nlko/UcYFnoTNPsOoUIZELfl52n7x9zRESZQThBFDv7RWHBr49/Ec2DFVjF7pI/IkysTXmKMWVa7it+oqKEHRqoYpIs0kkqlBBaBt7ikxa3JqM6knVAfVL7p X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:PA4PR08MB6061.eurprd08.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(1800799024)(376014)(23010399003)(366016)(22082099003)(18002099003)(261009223027099003)(56012099006)(4143699003)(261102123227099003)(261028144727099003)(261026140227099003)(261021121427099003)(261022105027099003)(261026121527099003)(261021123027099003)(261021135927099003)(10067099003); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?czBFcHk0WE9SK01lNVJ0SHFwWEJOMnpMWlVWNUVCUDA0cFZsUW43elE2Tlhv?= =?utf-8?B?MVpsQ0dJQjhWU1BhTHY3U2FUa01ZREZNT0RmaXhpMFQrRlJiWUhHdDJiTDUy?= =?utf-8?B?cDc5SmlRWWF2RExLdTBrblRaNzZvNElMbjJuei9WUGpsWWpvNm9kYmtEd2NS?= =?utf-8?B?QWhpbUFJN2tRU24xWldaNit3cXFxcWxleGVKc0dyNFVXeUV3UXBnY0NWNHIx?= =?utf-8?B?VGcvRnA3VzNxa0xoYnJMUGpaN1YrcTRuNFh2b0tmZ2UwcXdRYU5GbGpsR2ZL?= =?utf-8?B?cGJpMk05VmJtQkRWNCtmNGgxam1wM0gxblM4QXlZNzA4WFJJYU1UMnNBK05h?= =?utf-8?B?dkZmc0R5S3NPOE1ZdzArNnkzQm9tOS9EczR2c0JlWnBDYTc1RnM1WHpjWDlw?= =?utf-8?B?K2J6K1pVZ0JzcFlhVzZRaXpsMisvMTNCNVVaMVpZZW9ETGJHSDJVdVZ1RzZr?= =?utf-8?B?OW9kcHdEWHoweUlhWkMrNmtjMkFPR2dPQ0x3L2t6TUVMTzFGWkdQL0pyQnlD?= =?utf-8?B?REdDTlQzeHd1N1U1OUhrMWs5WlBqSXJmcGRzRmVFbjRLSEY2SXNSOFV1eTZ6?= =?utf-8?B?Y3BKVGIrcG1iZjVLU1U3WXordWdFVmpsTG9RdHhzcVNOck1xZVdOTFdIQWFy?= =?utf-8?B?YmFKcklnRmxBSm5HWkZRL1k4a3NzSTlJWnJTMk5jMlU3RWR2cDkxMGNrNnVy?= =?utf-8?B?Yk1kMDgvakNpaGZWb3FwcVg1N2wrR0J4eEhQTzdXNWxXbjgyMDRrekdNY0pM?= =?utf-8?B?YVgzNnNmd3N4YTU5TmZWRHlETzVwTXo2eTRFSEgvdk5BaXQySWxta29VUm1F?= =?utf-8?B?cGovMWVPYk52RW1JVm9kazFNVVJPMTVOZCs4c3EySW02dGNpdzViVlR6THk5?= =?utf-8?B?dVBOcU5QR2VOaHFXUW5JaXJXVEQrZ3ROVmhTZktCY2hseXlyVHAreEFCYTV1?= =?utf-8?B?aVRlOFBiQUwvRWFoY3c0QXhtMnJySXZzdXRtbzJhOEkrL01aeDJjcSt2K1dx?= =?utf-8?B?MHAxNlpwYkFuajd3amFmMTJXOXNiejVhNktwMk9tVnhxc1Z0V0Q0RlZKeG00?= =?utf-8?B?Q0FIN3YrOE1xQ2JacVVHbVZGVEtYY0RZQkNmOHRjYWJtQkJqSTVGL0VUS3o1?= =?utf-8?B?c1JsZzJkT3k2MnFFOGhkOEQrVnRsY0k0aExxN3lkVzdzTVpOazJXTFpHQ1VC?= =?utf-8?B?OGF6TG5FMHgwZmtMNE1IZGhrK3F5eWgydWlzZGM4U2xrcSs0MVRCVWVUdW5L?= =?utf-8?B?Y0R4VFVBUTB0M2hSY3FYVklQU3F6ZXBjc29sa29ZNU5kcXlWRkVTdVJONk1h?= =?utf-8?B?THduSUo3QS9SYmVqamlqaVJ2L2VLdk5GcnRGNlE5M2UyeHJjeXdtWTk4bzlM?= =?utf-8?B?R3VFQmdOTFJNMWRhdU5jcDlwck01d2t3RmYyMk43Z3RxZ1k2aWs4S1VOek5Q?= =?utf-8?B?S0U0QmkrR09kTEhlS2RmL0xNYlJ0ZGV6UC9GNStmM2NPUGJBOTBjRWZMdVM3?= =?utf-8?B?VkZtU2owY1M1SDE2TStmV3liTHFFR3N1ejJyTkZTTDNtYTJiREI3a3BqUHd1?= =?utf-8?B?NGNJTlFSZzFSVS9BMElrVGk0b25yNzIxemdtQkFjczNneTJydkY3OEk3aThO?= =?utf-8?B?N28wcFRTYWgwdUQyQ2NmeGZzV2pSOTI4RUUvbENHeVRNYktaSU02UE9LbzZP?= =?utf-8?B?VzU3d2VubkFNQWZDMjRrNmhteThQamlENnVFMzF3dXFDb1FZKzVBWGlmbUxp?= =?utf-8?B?WEhWRTMvT3o4MXV2WU4rNzJvSzFjaHdIbCt1Tlgra0hQa0R4YWxUWm4rOWVO?= =?utf-8?B?YkFDeHJPWUxaa2UybWJNU3NqSXdLZjdjZkQ0ODdDSHdXaGw3Ym4vckZ6K25V?= =?utf-8?B?QjVXbjUzM2crR3lmSUdWQ0ltbEZmWUoraXNGanFRNDlJYityQjZrbVhtUU80?= =?utf-8?B?eHdrc3RGVlpTTVBwQ2RKVHpkU05OOHozT2k4cGJEMXZFVVRoWnora1NsWEIx?= =?utf-8?B?T3E1SEVGWTQ1RHRGRmhnbEJqemxyY0hEQ3JibzcvTzIrbzM0YkphZitHN1pM?= =?utf-8?B?WVRndzFYc2JxUXUvYkpqWURSOEJjVmt5MDUzSkNaK2E3YVkzd3ptMm1KWi9G?= =?utf-8?B?VG81OWFIdTROWmxUMXdsZkJuVnAwa0Y1azA1OWpqQXhYUE5kNGVha3VFMDJ1?= =?utf-8?B?VXBnNnNVaW96RXFtdktKREduZzErT1ZnREMyUms0NU9RNkdFVGRwdlN2bXh1?= =?utf-8?B?a3J6OEhETnZidVNkU2dqOVFDWTBlZm9EK2NaUWRSWlY2WTlMSCsxVXBmaHFj?= =?utf-8?B?Uk9JSWxIc05Xc01MTDlyOVRjaUVNWmhEYVAzcENZdkkxdXNQam5HRXJpaThR?= =?utf-8?Q?X9g1ifL2t6FeaAyc=3D?= X-OriginatorOrg: virtuozzo.com X-MS-Exchange-CrossTenant-Network-Message-Id: 2923c0a8-3b09-4cb4-3e46-08df449e65a3 X-MS-Exchange-CrossTenant-AuthSource: PA4PR08MB6061.eurprd08.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 17 Nov 2026 11:32:01.3590 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 0bc7f26d-0264-416e-a6fc-8352af79c58f X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: k8gXXSLNfToP8N9cDprEctPuXQVj1yOdloJVgVrokXDQKAKG20O2ZX6gg7d/Fu4z+6LZ7UP+qw1QtwALt30GqMS0ivg5aG2sQ5gHDAHB07A= X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR08MB8226 X-OZ-Fwd: true Cc: devel@openvz.org Subject: Re: [Devel] [PATCH hci-8.1 v3 2/2] drivers/vhost/blk: support VIRTIO_BLK_F_WRITE_ZEROES X-BeenThere: devel@openvz.org X-Mailman-Version: 2.1.12 Precedence: list List-Id: OpenVZ development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="us-ascii"; Format="flowed" Sender: devel-bounces@openvz.org Errors-To: devel-bounces@openvz.org Generally speaking I think this is a wrong approach for our needs. This patch really overengineers the whole situation: - we should not build write requests if the device does not support zeroing. The correct way is to never advertise zeroes for such device. We can't do that in kernel because feature negotiation happens before backend is set. So we should check the limits in QEMU (which also should correctly set max_write_zeroes_sectors in config anyway, so the plumbing will be there) - vhost_blk_retry_zeroes() is probably nice but again not our case. This is a workaround when the device resets limits. We plan to use it with dm-qcow2 and we can just never reset the limit there (why would we if writing zeroes is just a few bits in cluster tables) So the whole patch shape should be - When we get zero request we just construct a simple bio with REQ_OP_WRITE_ZEROES and queue it. (maybe a little check to match bdev_write_zeroes_sectors) That's it. Let's not add some convoluted code we will never use. So first I would expect a QEMU patch that reads device zero support and sets max_write_zeroes_sectors limit. Then the simplified version of this patch. On 11/17/26 11:09, Alexander Ivanov wrote: > Handle VIRTIO_BLK_T_WRITE_ZEROES for parity with virtio-blk. The range > is zeroed with __blkdev_issue_zeroout(), which uses WRITE ZEROES of the > backend or falls back to writing zero pages. The UNMAP flag maps to > the absence of BLKDEV_ZERO_NOUNMAP. The range is issued in chunks of > at most 16 WRITE ZEROES bios and 1 GiB, or 4 MiB ones when zero pages > are written, since each chunk is built in the vhost worker. > > The VMM must advertise blk_size equal to the backend logical block > size, max_write_zeroes_sectors aligned to it and at most 8388607, and > max_write_zeroes_seg = 1. A request is zeroed one chunk at a time and > holds vhost_blk_flush() until its last chunk, so a small > max_write_zeroes_sectors keeps vhost ioctls short on backends without > WRITE ZEROES. Our QEMU does not advertise the feature yet. > > The guest gets VIRTIO_BLK_S_UNSUPP when VIRTIO_BLK_F_WRITE_ZEROES was > not negotiated, for a payload other than exactly one segment or an > unknown flag, and VIRTIO_BLK_S_IOERR for a read-only backend and for a > range that is unaligned, beyond the capacity or above 8388607 sectors. > > https://virtuozzo.atlassian.net/browse/VSTOR-141684 > Feature: vhost-blk: in-kernel accelerator for virtio-blk guests > Signed-off-by: Alexander Ivanov > --- > drivers/vhost/blk.c | 178 +++++++++++++++++++++++++++++++++++++++++++- > 1 file changed, 176 insertions(+), 2 deletions(-) > > diff --git a/drivers/vhost/blk.c b/drivers/vhost/blk.c > index eea8cca59cac..e27320651469 100644 > --- a/drivers/vhost/blk.c > +++ b/drivers/vhost/blk.c > @@ -29,7 +29,8 @@ enum { > (1ULL << VIRTIO_RING_F_INDIRECT_DESC) | > (1ULL << VIRTIO_RING_F_EVENT_IDX) | > (1ULL << VIRTIO_BLK_F_MQ) | > - (1ULL << VIRTIO_BLK_F_FLUSH), > + (1ULL << VIRTIO_BLK_F_FLUSH) | > + (1ULL << VIRTIO_BLK_F_WRITE_ZEROES), > }; > > /* > @@ -75,6 +76,10 @@ struct vhost_blk_req { > struct iovec status[VHOST_MAX_METADATA_IOV]; > > sector_t sector; > + sector_t nr_sects; > + sector_t chunk_sects; > + struct block_device *bdev; Do we really need bdev? As far as I can see in the only place we use it, it can be derived from req->blk->backend. In general we allocate a lot of vhost_blk_req beforehand and I would prefer to keeps this struct as tight as possible. > + unsigned int zeroout_flags; > int bi_opf; > u16 head; > size_t len; > @@ -271,6 +276,63 @@ static int vhost_blk_move_bb_to_req(struct vhost_blk_req *req) > return 0; > } > > +/* > + * The range is zeroed in the vhost worker with vq->mutex held, so it is > + * split into chunks of a few bios each, much smaller ones when zero pages > + * are written. The chunk sizes are multiples of any logical block size. > + */ > +#define VHOST_BLK_MAX_WRITE_ZEROES_BIOS 16 > +#define VHOST_BLK_MAX_WRITE_ZEROES_SECTORS (SZ_1G >> SECTOR_SHIFT) > +#define VHOST_BLK_MAX_ZERO_PAGES_SECTORS (SZ_4M >> SECTOR_SHIFT) > + > +/* > + * A request holds vhost_blk_flush() until its last chunk completes, so the > + * whole range is bounded too. No Linux guest sends more, a bio cannot carry > + * it. > + */ > +#define VHOST_BLK_MAX_WRITE_ZEROES_REQ_SECTORS (UINT_MAX >> SECTOR_SHIFT) > + > +static int vhost_blk_bio_make_zeroes(struct vhost_blk_req *req, > + struct block_device *bdev) > +{ > + sector_t bs_mask = (bdev_logical_block_size(bdev) >> SECTOR_SHIFT) - 1; > + sector_t max_sects = (sector_t)bdev_write_zeroes_sectors(bdev) * > + VHOST_BLK_MAX_WRITE_ZEROES_BIOS & ~bs_mask; > + struct bio *bio = NULL; > + int ret = -EOPNOTSUPP; > + > + req->chunk_sects = min3(req->nr_sects, max_sects, > + (sector_t)VHOST_BLK_MAX_WRITE_ZEROES_SECTORS); > + /* The limit may appear after it was read, and no bio is built then */ > + if (req->chunk_sects) > + ret = __blkdev_issue_zeroout(bdev, req->sector, > + req->chunk_sects, GFP_KERNEL, &bio, > + req->zeroout_flags | > + BLKDEV_ZERO_NOFALLBACK); > + if (ret == -EOPNOTSUPP) { > + req->chunk_sects = min_t(sector_t, req->nr_sects, > + VHOST_BLK_MAX_ZERO_PAGES_SECTORS); > + ret = __blkdev_issue_zeroout(bdev, req->sector, > + req->chunk_sects, GFP_KERNEL, &bio, > + req->zeroout_flags); > + } > + if (ret) > + return ret; > + > + bio->bi_private = req; > + bio->bi_end_io = vhost_blk_req_done; > + req->bio = req->inline_bio; > + req->bio[0] = bio; > + > + /* Zero pages are plain writes, a failure of them is not retried */ > + if (bio_op(bio) != REQ_OP_WRITE_ZEROES) > + req->bi_opf = REQ_OP_WRITE; > + > + atomic_set(&req->bio_nr, 1); > + > + return 0; > +} > + > static int vhost_blk_bio_make(struct vhost_blk_req *req, > struct block_device *bdev) > { > @@ -284,6 +346,9 @@ static int vhost_blk_bio_make(struct vhost_blk_req *req, > if (unlikely(req->bi_opf & REQ_PREFLUSH)) > return vhost_blk_bio_make_simple(req, bdev); > > + if (req->bi_opf == REQ_OP_WRITE_ZEROES) > + return vhost_blk_bio_make_zeroes(req, bdev); > + > /* > * Requests with unaligned io vectors are not supported by underlined > * block device, let's use an aligned intermediary "bounce buffer" to > @@ -451,6 +516,50 @@ static bool vhost_blk_backend_ro(struct file *f) > bdev_read_only(I_BDEV(f->f_mapping->host)); > } > > +static int vhost_blk_parse_write_zeroes(struct vhost_blk_req *req, u8 *status) > +{ > + struct file *f = vhost_vq_get_backend(&req->blk_vq->vq); > + struct block_device *bdev = I_BDEV(f->f_mapping->host); > + sector_t bs_mask = (bdev_logical_block_size(bdev) >> SECTOR_SHIFT) - 1; > + struct virtio_blk_discard_write_zeroes seg; > + struct iov_iter iter; > + u32 flags; > + > + if (!vhost_has_feature(&req->blk_vq->vq, VIRTIO_BLK_F_WRITE_ZEROES) || > + req->len != sizeof(seg)) { > + *status = VIRTIO_BLK_S_UNSUPP; > + return 0; > + } > + > + iov_iter_init(&iter, ITER_SOURCE, req->iov, req->iov_nr, req->len); > + if (copy_from_iter(&seg, sizeof(seg), &iter) != sizeof(seg)) > + return -EFAULT; > + > + flags = le32_to_cpu(seg.flags); > + if (flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) { > + *status = VIRTIO_BLK_S_UNSUPP; > + return 0; > + } > + > + req->sector = le64_to_cpu(seg.sector); > + req->nr_sects = le32_to_cpu(seg.num_sectors); > + req->bdev = bdev; > + req->zeroout_flags = flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP ? > + 0 : BLKDEV_ZERO_NOUNMAP; > + > + if (vhost_blk_backend_ro(f) || > + (req->sector | req->nr_sects) & bs_mask || > + req->nr_sects > VHOST_BLK_MAX_WRITE_ZEROES_REQ_SECTORS || > + req->sector > bdev_nr_sectors(bdev) || > + req->nr_sects > bdev_nr_sectors(bdev) - req->sector) { > + *status = VIRTIO_BLK_S_IOERR; > + return 0; > + } > + > + *status = VIRTIO_BLK_S_OK; > + return 0; > +} > + > static int vhost_blk_req_handle(struct vhost_virtqueue *vq, > struct virtio_blk_outhdr *hdr, > u16 head, u16 out, u16 in) > @@ -475,6 +584,7 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq, > req->head = head; > req->blk = blk; > req->sector = vhost64_to_cpu(vq, hdr->sector); > + req->nr_sects = 0; > req->iov = blk_vq->iov; > req->bio_err = 0; > in_len = iov_length(vq->iov + out, in); > @@ -490,7 +600,7 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq, > req->status[0].iov_base = st->iov_base + st->iov_len; > req->status[0].iov_len = sizeof(status); > > - if (type == VIRTIO_BLK_T_OUT) { > + if (type == VIRTIO_BLK_T_OUT || type == VIRTIO_BLK_T_WRITE_ZEROES) { > data_iov = vq->iov; > data_nr = out; > } else { > @@ -538,6 +648,22 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq, > req->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; > ret = vhost_blk_req_submit(req); > break; > + case VIRTIO_BLK_T_WRITE_ZEROES: > + ret = vhost_blk_parse_write_zeroes(req, &status); > + if (ret) > + break; > + if (status == VIRTIO_BLK_S_OK && req->nr_sects) { > + req->bi_opf = REQ_OP_WRITE_ZEROES; > + ret = vhost_blk_req_submit(req); > + if (ret != -EPERM) > + break; > + status = VIRTIO_BLK_S_IOERR; > + } > + ret = vhost_blk_set_status(req, status); > + if (ret) > + break; > + vhost_add_used_and_signal(&blk->dev, vq, head, sizeof(status)); > + break; > case VIRTIO_BLK_T_GET_ID: > len = min_t(size_t, > strnlen(blk->serial, VIRTIO_BLK_ID_BYTES) + 1, > @@ -561,6 +687,51 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq, > return ret; > } > > +/* > + * Some devices clear their WRITE ZEROES limit only after a failed request, > + * as blkdev_issue_write_zeroes() expects. Retry such a request with zero > + * pages instead of failing it. > + */ > +static bool vhost_blk_retry_zeroes(struct vhost_blk_req *req) > +{ > + if (!req->bio_err || req->bi_opf != REQ_OP_WRITE_ZEROES) > + return false; > + > + if (bdev_write_zeroes_sectors(req->bdev)) > + return false; > + > + /* The limit may come back before the bio is built, retry only once */ > + req->bi_opf = REQ_OP_WRITE; > + if (vhost_blk_bio_make_zeroes(req, req->bdev)) > + return false; > + > + req->bio_err = 0; > + vhost_blk_bio_send(req); > + return true; > +} > + > +/* Issue the next chunk of a write-zeroes range, if any is left */ > +static bool vhost_blk_next_zeroes(struct vhost_blk_req *req) > +{ > + int ret; > + > + if (req->bio_err || req->nr_sects <= req->chunk_sects) > + return false; > + > + req->sector += req->chunk_sects; > + req->nr_sects -= req->chunk_sects; > + > + req->bi_opf = REQ_OP_WRITE_ZEROES; > + ret = vhost_blk_bio_make_zeroes(req, req->bdev); > + if (ret) { > + req->bio_err = ret; > + return false; > + } > + > + vhost_blk_bio_send(req); > + return true; > +} > + > static void vhost_blk_handle_guest_kick(struct vhost_work *work) > { > struct virtio_blk_outhdr hdr; > @@ -661,6 +832,9 @@ static void vhost_blk_handle_host_kick(struct vhost_work *work) > if (!blk) > blk = req->blk; > > + if (vhost_blk_retry_zeroes(req) || vhost_blk_next_zeroes(req)) > + continue; > + > if (!req->bio_err && req->bb && req->bi_opf == REQ_OP_READ) { > if (vhost_blk_move_bb_to_req(req)) > req->bio_err = EINVAL; _______________________________________________ Devel mailing list Devel@openvz.org https://lists.openvz.org/mailman/listinfo/devel