From nobody Mon Feb 9 23:42:30 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1612879937; cv=none; d=zohomail.com; s=zohoarc; b=ZeL8aXToBREUCxckCtvs/+84DXxinpJDy0Et+5kzleVoLy/VRZMaV+EPD2/059D0q+aBPA2HMKDkJy4bQkCVF8mwM+1QqSGcNqxT4md9vpCdstDoN12ygwJbp8IfV6EF5Ti/cuCUdtEpFqVMg749q//oXzULaj+7y6PW68QuyCE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1612879937; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Vc9bL4wbnyWvWbZtV2TMXb0sknO2mVa8lIUDQEMxlvQ=; b=BdsxQ53cWqkrr7WBIk/SpkBUDG9+p7Ccr5GxC5NtNi2yxiCg4UyiI40KNJ7GabS/39pDJ3r8BJnRJjkcX8K5VQoA4/rjLiyX6SAWbSQMvT4cld3eBQXfmlXrUrsvyS2nYVb5rSyeUSwIk8+gAXKVk93p/PrTEih3AvOpYGI5F9Q= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 161287993715918.73148205966845; Tue, 9 Feb 2021 06:12:17 -0800 (PST) Received: from localhost ([::1]:37148 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l9TkS-0003V0-FM for importer@patchew.org; Tue, 09 Feb 2021 09:12:12 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:40904) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1l9TQK-0002zl-Es for qemu-devel@nongnu.org; Tue, 09 Feb 2021 08:51:25 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:58901) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1l9TQI-0005ay-FZ for qemu-devel@nongnu.org; Tue, 09 Feb 2021 08:51:24 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-56-RGX7Tb8qMZefx5fcRA58ow-1; Tue, 09 Feb 2021 08:51:19 -0500 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id DBA48100CCC2; Tue, 9 Feb 2021 13:51:17 +0000 (UTC) Received: from t480s.redhat.com (ovpn-113-141.ams2.redhat.com [10.36.113.141]) by smtp.corp.redhat.com (Postfix) with ESMTP id DC9CD6F971; Tue, 9 Feb 2021 13:51:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1612878681; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Vc9bL4wbnyWvWbZtV2TMXb0sknO2mVa8lIUDQEMxlvQ=; b=FJQ7KhzDEq9e32SGKppeHKW/iS54ENS1sWqm+JPiN/YpuQ1mwtQibmymuV9ecE9mqNwHFe 3u8DGw8TFmYWOyVYIiRIdEOuLVG1skRAnwvt4ansIr7yk9D0Bf5QTPK1eKPPubI5UKrORd 2t7AUtAlhhp+fKpesX0GHGW9NeutcU0= X-MC-Unique: RGX7Tb8qMZefx5fcRA58ow-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v1 8/9] util/mmap-alloc: support RAM_NORESERVE via MAP_NORESERVE Date: Tue, 9 Feb 2021 14:49:38 +0100 Message-Id: <20210209134939.13083-9-david@redhat.com> In-Reply-To: <20210209134939.13083-1-david@redhat.com> References: <20210209134939.13083-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -33 X-Spam_score: -3.4 X-Spam_bar: --- X-Spam_report: (-3.4 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.57, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, 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.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Juan Quintela , Murilo Opsfelder Araujo , Cornelia Huck , Eduardo Habkost , "Michael S. Tsirkin" , Stefan Weil , David Hildenbrand , Richard Henderson , "Dr. David Alan Gilbert" , Peter Xu , Greg Kurz , Halil Pasic , Christian Borntraeger , Stefan Hajnoczi , Igor Mammedov , Thomas Huth , Paolo Bonzini , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Igor Kotrasinski Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Let's support RAM_NORESERVE via MAP_NORESERVE. At least on Linux, the flag has no effect on shared mappings - except for anonymous memory and hugetlbfs. Linux man page: "MAP_NORESERVE: Do not reserve swap space for this mapping. When swap space is reserved, one has the guarantee that it is possible to modify the mapping. When swap space is not reserved one might get SIGSEGV upon a write if no physical memory is available. See also the discussion of the file /proc/sys/vm/overcommit_memory in proc(5). In kernels before 2.6, this flag had effect only for private writable mappings." Note that the "guarantee" part is wrong with memory overcommit in Linux. Also, in Linux hugetlbfs is treated differently - we configure reservation of huge pages from the pool, not reservation of swap space (huge pages cannot be swapped). The rough behavior is [1]: a) !Hugetlbfs: 1) Without MAP_NORESERVE *or* with memory overcommit under Linux disabled ("/proc/sys/vm/overcommit_memory =3D=3D 2"), the following accounting/reservation happens: For a file backed map SHARED or READ-only - 0 cost (the file is the map not swap) PRIVATE WRITABLE - size of mapping per instance For an anonymous or /dev/zero map SHARED - size of mapping PRIVATE READ-only - 0 cost (but of little use) PRIVATE WRITABLE - size of mapping per instance 2) With MAP_NORESERVE, no accounting/reservation happens. b) Hugetlbfs: 1) Without MAP_NORESERVE, huge pages are reserved. 2) With MAP_NORESERVE, no huge pages are reserved. Note: With "/proc/sys/vm/overcommit_memory =3D=3D 0", we were already able to configure it for !hugetlbfs globally; this toggle now allows configuring it more fine-grained, not for the whole system. The target use case is virtio-mem, which dynamically exposes memory inside a large, sparse memory area to the VM. [1] https://www.kernel.org/doc/Documentation/vm/overcommit-accounting Signed-off-by: David Hildenbrand --- softmmu/physmem.c | 1 + util/mmap-alloc.c | 47 +++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 44 insertions(+), 4 deletions(-) diff --git a/softmmu/physmem.c b/softmmu/physmem.c index 9820d845c0..f45a85add1 100644 --- a/softmmu/physmem.c +++ b/softmmu/physmem.c @@ -2248,6 +2248,7 @@ void qemu_ram_remap(ram_addr_t addr, ram_addr_t lengt= h) abort(); } else { flags =3D MAP_FIXED; + flags |=3D (block->flags & RAM_NORESERVE) ? MAP_NORESERVE = : 0; if (block->fd >=3D 0) { flags |=3D (block->flags & RAM_SHARED ? MAP_SHARED : MAP_PRIVATE); diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c index bb99843106..f77d9ca574 100644 --- a/util/mmap-alloc.c +++ b/util/mmap-alloc.c @@ -20,6 +20,7 @@ #include "qemu/osdep.h" #include "qemu/mmap-alloc.h" #include "qemu/host-utils.h" +#include "qemu/cutils.h" #include "qemu/error-report.h" =20 #define HUGETLBFS_MAGIC 0x958458f6 @@ -120,7 +121,7 @@ static void *mmap_reserve(size_t size, int fd) * it accessible. */ static void *mmap_activate(void *ptr, size_t size, int fd, bool readonly, - bool shared, bool is_pmem) + bool shared, bool is_pmem, bool noreserve) { const int prot =3D PROT_READ | (readonly ? 0 : PROT_WRITE); int map_sync_flags =3D 0; @@ -129,6 +130,7 @@ static void *mmap_activate(void *ptr, size_t size, int = fd, bool readonly, =20 flags |=3D fd =3D=3D -1 ? MAP_ANONYMOUS : 0; flags |=3D shared ? MAP_SHARED : MAP_PRIVATE; + flags |=3D noreserve ? MAP_NORESERVE : 0; if (shared && is_pmem) { map_sync_flags =3D MAP_SYNC | MAP_SHARED_VALIDATE; } @@ -170,6 +172,43 @@ static inline size_t mmap_guard_pagesize(int fd) #endif } =20 +#define OVERCOMMIT_MEMORY_PATH "/proc/sys/vm/overcommit_memory" +static bool map_noreserve_effective(int fd, bool shared) +{ +#if defined(__linux__) + gchar *content =3D NULL; + const char *endptr; + unsigned int tmp; + + /* hugetlbfs behaves differently */ + if (qemu_fd_getpagesize(fd) !=3D qemu_real_host_page_size) { + return true; + } + + /* only private shared mappings are accounted (ignoring /dev/zero) */ + if (fd !=3D -1 && shared) { + return true; + } + + if (g_file_get_contents(OVERCOMMIT_MEMORY_PATH, &content, NULL, NULL) = && + !qemu_strtoui(content, &endptr, 0, &tmp) && + (!endptr || *endptr =3D=3D '\n')) { + if (tmp =3D=3D 2) { + error_report("Skipping reservation of swap space is not suppor= ted: " + " \"" OVERCOMMIT_MEMORY_PATH "\" is \"2\""); + return false; + } + return true; + } + /* this interface has been around since Linux 2.6 */ + error_report("Skipping reservation of swap space is not supported: " + " Could not read: \"" OVERCOMMIT_MEMORY_PATH "\""); + return false; +#else + return true; +#endif +} + void *qemu_ram_mmap(int fd, size_t size, size_t align, @@ -182,8 +221,7 @@ void *qemu_ram_mmap(int fd, size_t offset, total; void *ptr, *guardptr; =20 - if (noreserve) { - error_report("Skipping reservation of swap space is not supported"= ); + if (noreserve && !map_noreserve_effective(fd, shared)) { return MAP_FAILED; } =20 @@ -204,7 +242,8 @@ void *qemu_ram_mmap(int fd, =20 offset =3D QEMU_ALIGN_UP((uintptr_t)guardptr, align) - (uintptr_t)guar= dptr; =20 - ptr =3D mmap_activate(guardptr + offset, size, fd, readonly, shared, i= s_pmem); + ptr =3D mmap_activate(guardptr + offset, size, fd, readonly, shared, i= s_pmem, + noreserve); if (ptr =3D=3D MAP_FAILED) { munmap(guardptr, total); return MAP_FAILED; --=20 2.29.2