[Qemu-devel] [PATCH v9 15/56] Add Linux userfaultfd.h header

[Dr. David Alan Gilbert (git)]

From: "Dr. David Alan Gilbert" <address@hidden>

Postcopy uses the userfaultfd.h feature in the Linux kernel; include
the header.

(In early versions of the patch series we had this, and then we dropped
this by only including it if the kernel headers defined the syscall
number; however 1842bdfd added the syscall definition to our
headers, which means we can't tell if the kernel has it or not)

Signed-off-by: Dr. David Alan Gilbert <address@hidden>
---
 linux-headers/linux/userfaultfd.h | 167 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 linux-headers/linux/userfaultfd.h

diff --git a/linux-headers/linux/userfaultfd.h 
b/linux-headers/linux/userfaultfd.h
new file mode 100644
index 0000000..9057d7a
--- /dev/null
+++ b/linux-headers/linux/userfaultfd.h
@@ -0,0 +1,167 @@
+/*
+ *  include/linux/userfaultfd.h
+ *
+ *  Copyright (C) 2007  Davide Libenzi <address@hidden>
+ *  Copyright (C) 2015  Red Hat, Inc.
+ *
+ */
+
+#ifndef _LINUX_USERFAULTFD_H
+#define _LINUX_USERFAULTFD_H
+
+#include <linux/types.h>
+
+#define UFFD_API ((__u64)0xAA)
+/*
+ * After implementing the respective features it will become:
+ * #define UFFD_API_FEATURES (UFFD_FEATURE_PAGEFAULT_FLAG_WP | \
+ *                           UFFD_FEATURE_EVENT_FORK)
+ */
+#define UFFD_API_FEATURES (0)
+#define UFFD_API_IOCTLS                                \
+       ((__u64)1 << _UFFDIO_REGISTER |         \
+        (__u64)1 << _UFFDIO_UNREGISTER |       \
+        (__u64)1 << _UFFDIO_API)
+#define UFFD_API_RANGE_IOCTLS                  \
+       ((__u64)1 << _UFFDIO_WAKE |             \
+        (__u64)1 << _UFFDIO_COPY |             \
+        (__u64)1 << _UFFDIO_ZEROPAGE)
+
+/*
+ * Valid ioctl command number range with this API is from 0x00 to
+ * 0x3F.  UFFDIO_API is the fixed number, everything else can be
+ * changed by implementing a different UFFD_API. If sticking to the
+ * same UFFD_API more ioctl can be added and userland will be aware of
+ * which ioctl the running kernel implements through the ioctl command
+ * bitmask written by the UFFDIO_API.
+ */
+#define _UFFDIO_REGISTER               (0x00)
+#define _UFFDIO_UNREGISTER             (0x01)
+#define _UFFDIO_WAKE                   (0x02)
+#define _UFFDIO_COPY                   (0x03)
+#define _UFFDIO_ZEROPAGE               (0x04)
+#define _UFFDIO_API                    (0x3F)
+
+/* userfaultfd ioctl ids */
+#define UFFDIO 0xAA
+#define UFFDIO_API             _IOWR(UFFDIO, _UFFDIO_API,      \
+                                     struct uffdio_api)
+#define UFFDIO_REGISTER                _IOWR(UFFDIO, _UFFDIO_REGISTER, \
+                                     struct uffdio_register)
+#define UFFDIO_UNREGISTER      _IOR(UFFDIO, _UFFDIO_UNREGISTER,        \
+                                    struct uffdio_range)
+#define UFFDIO_WAKE            _IOR(UFFDIO, _UFFDIO_WAKE,      \
+                                    struct uffdio_range)
+#define UFFDIO_COPY            _IOWR(UFFDIO, _UFFDIO_COPY,     \
+                                     struct uffdio_copy)
+#define UFFDIO_ZEROPAGE                _IOWR(UFFDIO, _UFFDIO_ZEROPAGE, \
+                                     struct uffdio_zeropage)
+
+/* read() structure */
+struct uffd_msg {
+       __u8    event;
+
+       __u8    reserved1;
+       __u16   reserved2;
+       __u32   reserved3;
+
+       union {
+               struct {
+                       __u64   flags;
+                       __u64   address;
+               } pagefault;
+
+               struct {
+                       /* unused reserved fields */
+                       __u64   reserved1;
+                       __u64   reserved2;
+                       __u64   reserved3;
+               } reserved;
+       } arg;
+} __packed;
+
+/*
+ * Start at 0x12 and not at 0 to be more strict against bugs.
+ */
+#define UFFD_EVENT_PAGEFAULT   0x12
+#if 0 /* not available yet */
+#define UFFD_EVENT_FORK                0x13
+#endif
+
+/* flags for UFFD_EVENT_PAGEFAULT */
+#define UFFD_PAGEFAULT_FLAG_WRITE      (1<<0)  /* If this was a write fault */
+#define UFFD_PAGEFAULT_FLAG_WP         (1<<1)  /* If reason is VM_UFFD_WP */
+
+struct uffdio_api {
+       /* userland asks for an API number and the features to enable */
+       __u64 api;
+       /*
+        * Kernel answers below with the all available features for
+        * the API, this notifies userland of which events and/or
+        * which flags for each event are enabled in the current
+        * kernel.
+        *
+        * Note: UFFD_EVENT_PAGEFAULT and UFFD_PAGEFAULT_FLAG_WRITE
+        * are to be considered implicitly always enabled in all kernels as
+        * long as the uffdio_api.api requested matches UFFD_API.
+        */
+#if 0 /* not available yet */
+#define UFFD_FEATURE_PAGEFAULT_FLAG_WP         (1<<0)
+#define UFFD_FEATURE_EVENT_FORK                        (1<<1)
+#endif
+       __u64 features;
+
+       __u64 ioctls;
+};
+
+struct uffdio_range {
+       __u64 start;
+       __u64 len;
+};
+
+struct uffdio_register {
+       struct uffdio_range range;
+#define UFFDIO_REGISTER_MODE_MISSING   ((__u64)1<<0)
+#define UFFDIO_REGISTER_MODE_WP                ((__u64)1<<1)
+       __u64 mode;
+
+       /*
+        * kernel answers which ioctl commands are available for the
+        * range, keep at the end as the last 8 bytes aren't read.
+        */
+       __u64 ioctls;
+};
+
+struct uffdio_copy {
+       __u64 dst;
+       __u64 src;
+       __u64 len;
+       /*
+        * There will be a wrprotection flag later that allows to map
+        * pages wrprotected on the fly. And such a flag will be
+        * available if the wrprotection ioctl are implemented for the
+        * range according to the uffdio_register.ioctls.
+        */
+#define UFFDIO_COPY_MODE_DONTWAKE              ((__u64)1<<0)
+       __u64 mode;
+
+       /*
+        * "copy" is written by the ioctl and must be at the end: the
+        * copy_from_user will not read the last 8 bytes.
+        */
+       __s64 copy;
+};
+
+struct uffdio_zeropage {
+       struct uffdio_range range;
+#define UFFDIO_ZEROPAGE_MODE_DONTWAKE          ((__u64)1<<0)
+       __u64 mode;
+
+       /*
+        * "zeropage" is written by the ioctl and must be at the end:
+        * the copy_from_user will not read the last 8 bytes.
+        */
+       __s64 zeropage;
+};
+
+#endif /* _LINUX_USERFAULTFD_H */
-- 
2.5.0