[01/21] Increase default MLOCK_LIMIT to 8 MiB

Commit Message

Andrew Morton Dec. 10, 2021, 10:46 p.m. UTC

From: Drew DeVault <[e-mail]>
Subject: Increase default MLOCK_LIMIT to 8 MiB

This limit has not been updated since 2008, when it was increased to 64
KiB at the request of GnuPG.  Until recently, the main use-cases for this
feature were (1) preventing sensitive memory from being swapped, as in
GnuPG's use-case; and (2) real-time use-cases.  In the first case, little
memory is called for, and in the second case, the user is generally in a
position to increase it if they need more.

The introduction of IOURING_REGISTER_BUFFERS adds a third use-case:
preparing fixed buffers for high-performance I/O.  This use-case will take
as much of this memory as it can get, but is still limited to 64 KiB by
default, which is very little.  This increases the limit to 8 MB, which
was chosen fairly arbitrarily as a more generous, but still conservative,
default value.

It is also possible to raise this limit in userspace.  This is easily
done, for example, in the use-case of a network daemon: systemd, for
instance, provides for this via LimitMEMLOCK in the service file; OpenRC
via the rc_ulimit variables.  However, there is no established userspace
facility for configuring this outside of daemons: end-user applications do
not presently have access to a convenient means of raising their limits.

The buck, as it were, stops with the kernel.  It's much easier to address
it here than it is to bring it to hundreds of distributions, and it can
only realistically be relied upon to be high-enough by end-user software
if it is more-or-less ubiquitous.  Most distros don't change this
particular rlimit from the kernel-supplied default value, so a change here
will easily provide that ubiquity.

Link: https://lkml.kernel.org/r/[e-mail]
Signed-off-by: Drew DeVault <[e-mail]>
Acked-by: Jens Axboe <[e-mail]>
Acked-by: Cyril Hrubis <[e-mail]>
Acked-by: Johannes Weiner <[e-mail]>
Cc: Pavel Begunkov <[e-mail]>
Cc: David Hildenbrand <[e-mail]>
Cc: Jason Gunthorpe <[e-mail]>
Cc: Andrew Dona-Couch <[e-mail]>
Cc: Ammar Faizi <[e-mail]>
Signed-off-by: Andrew Morton <[e-mail]>
---

 include/uapi/linux/resource.h |   13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

Comments

Linus Torvalds Dec. 11, 2021, 1:08 a.m. UTC | #1

On Fri, Dec 10, 2021 at 2:46 PM Andrew Morton <[e-mail]> wrote:
>
> -#define MLOCK_LIMIT    ((PAGE_SIZE > 64*1024) ? PAGE_SIZE : 64*1024)
> +#define MLOCK_LIMIT    ((PAGE_SIZE > 8*1024*1024) ? PAGE_SIZE : 8*1024*1024)

I think I'll just make this

  #define MLOCK_LIMIT    (8*1024*1024)

because at the point where it's that big, there's no point in
comparing it against PAGE_SIZE any more.

If some config has that big of a page size, all the rest of the kernel
infrastructure would basically be screwed. We do a lot of core kernel
allocations in one-page chunks..

            Linus

Patch

--- a/include/uapi/linux/resource.h~increase-default-mlock_limit-to-8-mib
+++ a/include/uapi/linux/resource.h
@@ -66,10 +66,17 @@  struct rlimit64 {
 #define _STK_LIM	(8*1024*1024)
 
 /*
- * GPG2 wants 64kB of mlocked memory, to make sure pass phrases
- * and other sensitive information are never written to disk.
+ * Limit the amount of locked memory by some sane default:
+ * root can always increase this limit if needed.
+ *
+ * The main use-cases are (1) preventing sensitive memory
+ * from being swapped; (2) real-time operations; (3) via
+ * IOURING_REGISTER_BUFFERS.
+ *
+ * The first two don't need much. The latter will take as
+ * much as it can get. 8MB is a reasonably sane default.
  */
-#define MLOCK_LIMIT	((PAGE_SIZE > 64*1024) ? PAGE_SIZE : 64*1024)
+#define MLOCK_LIMIT	((PAGE_SIZE > 8*1024*1024) ? PAGE_SIZE : 8*1024*1024)
 
 /*
  * Due to binary compatibility, the actual resource numbers