| 1 |
=========== |
| 2 |
Userfaultfd |
| 3 |
=========== |
| 4 |
|
| 5 |
Objective |
| 6 |
========= |
| 7 |
|
| 8 |
Userfaults allow the implementation of on-demand paging from userland |
| 9 |
and more generally they allow userland to take control of various |
| 10 |
memory page faults, something otherwise only the kernel code could do. |
| 11 |
|
| 12 |
For example userfaults allows a proper and more optimal implementation |
| 13 |
of the ``PROT_NONE+SIGSEGV`` trick. |
| 14 |
|
| 15 |
Design |
| 16 |
====== |
| 17 |
|
| 18 |
Userspace creates a new userfaultfd, initializes it, and registers one or more |
| 19 |
regions of virtual memory with it. Then, any page faults which occur within the |
| 20 |
region(s) result in a message being delivered to the userfaultfd, notifying |
| 21 |
userspace of the fault. |
| 22 |
|
| 23 |
The ``userfaultfd`` (aside from registering and unregistering virtual |
| 24 |
memory ranges) provides two primary functionalities: |
| 25 |
|
| 26 |
1) ``read/POLLIN`` protocol to notify a userland thread of the faults |
| 27 |
happening |
| 28 |
|
| 29 |
2) various ``UFFDIO_*`` ioctls that can manage the virtual memory regions |
| 30 |
registered in the ``userfaultfd`` that allows userland to efficiently |
| 31 |
resolve the userfaults it receives via 1) or to manage the virtual |
| 32 |
memory in the background |
| 33 |
|
| 34 |
The real advantage of userfaults if compared to regular virtual memory |
| 35 |
management of mremap/mprotect is that the userfaults in all their |
| 36 |
operations never involve heavyweight structures like vmas (in fact the |
| 37 |
``userfaultfd`` runtime load never takes the mmap_lock for writing). |
| 38 |
Vmas are not suitable for page- (or hugepage) granular fault tracking |
| 39 |
when dealing with virtual address spaces that could span |
| 40 |
Terabytes. Too many vmas would be needed for that. |
| 41 |
|
| 42 |
The ``userfaultfd``, once created, can also be |
| 43 |
passed using unix domain sockets to a manager process, so the same |
| 44 |
manager process could handle the userfaults of a multitude of |
| 45 |
different processes without them being aware about what is going on |
| 46 |
(well of course unless they later try to use the ``userfaultfd`` |
| 47 |
themselves on the same region the manager is already tracking, which |
| 48 |
is a corner case that would currently return ``-EBUSY``). |
| 49 |
|
| 50 |
API |
| 51 |
=== |
| 52 |
|
| 53 |
Creating a userfaultfd |
| 54 |
---------------------- |
| 55 |
|
| 56 |
There are two ways to create a new userfaultfd, each of which provide ways to |
| 57 |
restrict access to this functionality (since historically userfaultfds which |
| 58 |
handle kernel page faults have been a useful tool for exploiting the kernel). |
| 59 |
|
| 60 |
The first way, supported since userfaultfd was introduced, is the |
| 61 |
userfaultfd(2) syscall. Access to this is controlled in several ways: |
| 62 |
|
| 63 |
- Any user can always create a userfaultfd which traps userspace page faults |
| 64 |
only. Such a userfaultfd can be created using the userfaultfd(2) syscall |
| 65 |
with the flag UFFD_USER_MODE_ONLY. |
| 66 |
|
| 67 |
- In order to also trap kernel page faults for the address space, either the |
| 68 |
process needs the CAP_SYS_PTRACE capability, or the system must have |
| 69 |
vm.unprivileged_userfaultfd set to 1. By default, vm.unprivileged_userfaultfd |
| 70 |
is set to 0. |
| 71 |
|
| 72 |
The second way, added to the kernel more recently, is by opening |
| 73 |
/dev/userfaultfd and issuing a USERFAULTFD_IOC_NEW ioctl to it. This method |
| 74 |
yields equivalent userfaultfds to the userfaultfd(2) syscall. |
| 75 |
|
| 76 |
Unlike userfaultfd(2), access to /dev/userfaultfd is controlled via normal |
| 77 |
filesystem permissions (user/group/mode), which gives fine grained access to |
| 78 |
userfaultfd specifically, without also granting other unrelated privileges at |
| 79 |
the same time (as e.g. granting CAP_SYS_PTRACE would do). Users who have access |
| 80 |
to /dev/userfaultfd can always create userfaultfds that trap kernel page faults; |
| 81 |
vm.unprivileged_userfaultfd is not considered. |
| 82 |
|
| 83 |
Initializing a userfaultfd |
| 84 |
-------------------------- |
| 85 |
|
| 86 |
When first opened the ``userfaultfd`` must be enabled invoking the |
| 87 |
``UFFDIO_API`` ioctl specifying a ``uffdio_api.api`` value set to ``UFFD_API`` (or |
| 88 |
a later API version) which will specify the ``read/POLLIN`` protocol |
| 89 |
userland intends to speak on the ``UFFD`` and the ``uffdio_api.features`` |
| 90 |
userland requires. The ``UFFDIO_API`` ioctl if successful (i.e. if the |
| 91 |
requested ``uffdio_api.api`` is spoken also by the running kernel and the |
| 92 |
requested features are going to be enabled) will return into |
| 93 |
``uffdio_api.features`` and ``uffdio_api.ioctls`` two 64bit bitmasks of |
| 94 |
respectively all the available features of the read(2) protocol and |
| 95 |
the generic ioctl available. |
| 96 |
|
| 97 |
The ``uffdio_api.features`` bitmask returned by the ``UFFDIO_API`` ioctl |
| 98 |
defines what memory types are supported by the ``userfaultfd`` and what |
| 99 |
events, except page fault notifications, may be generated: |
| 100 |
|
| 101 |
- The ``UFFD_FEATURE_EVENT_*`` flags indicate that various other events |
| 102 |
other than page faults are supported. These events are described in more |
| 103 |
detail below in the `Non-cooperative userfaultfd`_ section. |
| 104 |
|
| 105 |
- ``UFFD_FEATURE_MISSING_HUGETLBFS`` and ``UFFD_FEATURE_MISSING_SHMEM`` |
| 106 |
indicate that the kernel supports ``UFFDIO_REGISTER_MODE_MISSING`` |
| 107 |
registrations for hugetlbfs and shared memory (covering all shmem APIs, |
| 108 |
i.e. tmpfs, ``IPCSHM``, ``/dev/zero``, ``MAP_SHARED``, ``memfd_create``, |
| 109 |
etc) virtual memory areas, respectively. |
| 110 |
|
| 111 |
- ``UFFD_FEATURE_MINOR_HUGETLBFS`` indicates that the kernel supports |
| 112 |
``UFFDIO_REGISTER_MODE_MINOR`` registration for hugetlbfs virtual memory |
| 113 |
areas. ``UFFD_FEATURE_MINOR_SHMEM`` is the analogous feature indicating |
| 114 |
support for shmem virtual memory areas. |
| 115 |
|
| 116 |
- ``UFFD_FEATURE_MOVE`` indicates that the kernel supports moving an |
| 117 |
existing page contents from userspace. |
| 118 |
|
| 119 |
The userland application should set the feature flags it intends to use |
| 120 |
when invoking the ``UFFDIO_API`` ioctl, to request that those features be |
| 121 |
enabled if supported. |
| 122 |
|
| 123 |
Once the ``userfaultfd`` API has been enabled the ``UFFDIO_REGISTER`` |
| 124 |
ioctl should be invoked (if present in the returned ``uffdio_api.ioctls`` |
| 125 |
bitmask) to register a memory range in the ``userfaultfd`` by setting the |
| 126 |
uffdio_register structure accordingly. The ``uffdio_register.mode`` |
| 127 |
bitmask will specify to the kernel which kind of faults to track for |
| 128 |
the range. The ``UFFDIO_REGISTER`` ioctl will return the |
| 129 |
``uffdio_register.ioctls`` bitmask of ioctls that are suitable to resolve |
| 130 |
userfaults on the range registered. Not all ioctls will necessarily be |
| 131 |
supported for all memory types (e.g. anonymous memory vs. shmem vs. |
| 132 |
hugetlbfs), or all types of intercepted faults. |
| 133 |
|
| 134 |
Userland can use the ``uffdio_register.ioctls`` to manage the virtual |
| 135 |
address space in the background (to add or potentially also remove |
| 136 |
memory from the ``userfaultfd`` registered range). This means a userfault |
| 137 |
could be triggering just before userland maps in the background the |
| 138 |
user-faulted page. |
| 139 |
|
| 140 |
Resolving Userfaults |
| 141 |
-------------------- |
| 142 |
|
| 143 |
There are three basic ways to resolve userfaults: |
| 144 |
|
| 145 |
- ``UFFDIO_COPY`` atomically copies some existing page contents from |
| 146 |
userspace. |
| 147 |
|
| 148 |
- ``UFFDIO_ZEROPAGE`` atomically zeros the new page. |
| 149 |
|
| 150 |
- ``UFFDIO_CONTINUE`` maps an existing, previously-populated page. |
| 151 |
|
| 152 |
These operations are atomic in the sense that they guarantee nothing can |
| 153 |
see a half-populated page, since readers will keep userfaulting until the |
| 154 |
operation has finished. |
| 155 |
|
| 156 |
By default, these wake up userfaults blocked on the range in question. |
| 157 |
They support a ``UFFDIO_*_MODE_DONTWAKE`` ``mode`` flag, which indicates |
| 158 |
that waking will be done separately at some later time. |
| 159 |
|
| 160 |
Which ioctl to choose depends on the kind of page fault, and what we'd |
| 161 |
like to do to resolve it: |
| 162 |
|
| 163 |
- For ``UFFDIO_REGISTER_MODE_MISSING`` faults, the fault needs to be |
| 164 |
resolved by either providing a new page (``UFFDIO_COPY``), or mapping |
| 165 |
the zero page (``UFFDIO_ZEROPAGE``). By default, the kernel would map |
| 166 |
the zero page for a missing fault. With userfaultfd, userspace can |
| 167 |
decide what content to provide before the faulting thread continues. |
| 168 |
|
| 169 |
- For ``UFFDIO_REGISTER_MODE_MINOR`` faults, there is an existing page (in |
| 170 |
the page cache). Userspace has the option of modifying the page's |
| 171 |
contents before resolving the fault. Once the contents are correct |
| 172 |
(modified or not), userspace asks the kernel to map the page and let the |
| 173 |
faulting thread continue with ``UFFDIO_CONTINUE``. |
| 174 |
|
| 175 |
Notes: |
| 176 |
|
| 177 |
- You can tell which kind of fault occurred by examining |
| 178 |
``pagefault.flags`` within the ``uffd_msg``, checking for the |
| 179 |
``UFFD_PAGEFAULT_FLAG_*`` flags. |
| 180 |
|
| 181 |
- None of the page-delivering ioctls default to the range that you |
| 182 |
registered with. You must fill in all fields for the appropriate |
| 183 |
ioctl struct including the range. |
| 184 |
|
| 185 |
- You get the address of the access that triggered the missing page |
| 186 |
event out of a struct uffd_msg that you read in the thread from the |
| 187 |
uffd. You can supply as many pages as you want with these IOCTLs. |
| 188 |
Keep in mind that unless you used DONTWAKE then the first of any of |
| 189 |
those IOCTLs wakes up the faulting thread. |
| 190 |
|
| 191 |
- Be sure to test for all errors including |
| 192 |
(``pollfd[0].revents & POLLERR``). This can happen, e.g. when ranges |
| 193 |
supplied were incorrect. |
| 194 |
|
| 195 |
Write Protect Notifications |
| 196 |
--------------------------- |
| 197 |
|
| 198 |
This is equivalent to (but faster than) using mprotect and a SIGSEGV |
| 199 |
signal handler. |
| 200 |
|
| 201 |
Firstly you need to register a range with ``UFFDIO_REGISTER_MODE_WP``. |
| 202 |
Instead of using mprotect(2) you use |
| 203 |
``ioctl(uffd, UFFDIO_WRITEPROTECT, struct *uffdio_writeprotect)`` |
| 204 |
while ``mode = UFFDIO_WRITEPROTECT_MODE_WP`` |
| 205 |
in the struct passed in. The range does not default to and does not |
| 206 |
have to be identical to the range you registered with. You can write |
| 207 |
protect as many ranges as you like (inside the registered range). |
| 208 |
Then, in the thread reading from uffd the struct will have |
| 209 |
``msg.arg.pagefault.flags & UFFD_PAGEFAULT_FLAG_WP`` set. Now you send |
| 210 |
``ioctl(uffd, UFFDIO_WRITEPROTECT, struct *uffdio_writeprotect)`` |
| 211 |
again while ``pagefault.mode`` does not have ``UFFDIO_WRITEPROTECT_MODE_WP`` |
| 212 |
set. This wakes up the thread which will continue to run with writes. This |
| 213 |
allows you to do the bookkeeping about the write in the uffd reading |
| 214 |
thread before the ioctl. |
| 215 |
|
| 216 |
If you registered with both ``UFFDIO_REGISTER_MODE_MISSING`` and |
| 217 |
``UFFDIO_REGISTER_MODE_WP`` then you need to think about the sequence in |
| 218 |
which you supply a page and undo write protect. Note that there is a |
| 219 |
difference between writes into a WP area and into a !WP area. The |
| 220 |
former will have ``UFFD_PAGEFAULT_FLAG_WP`` set, the latter |
| 221 |
``UFFD_PAGEFAULT_FLAG_WRITE``. The latter did not fail on protection but |
| 222 |
you still need to supply a page when ``UFFDIO_REGISTER_MODE_MISSING`` was |
| 223 |
used. |
| 224 |
|
| 225 |
Userfaultfd write-protect mode currently behave differently on none ptes |
| 226 |
(when e.g. page is missing) over different types of memories. |
| 227 |
|
| 228 |
For anonymous memory, ``ioctl(UFFDIO_WRITEPROTECT)`` will ignore none ptes |
| 229 |
(e.g. when pages are missing and not populated). For file-backed memories |
| 230 |
like shmem and hugetlbfs, none ptes will be write protected just like a |
| 231 |
present pte. In other words, there will be a userfaultfd write fault |
| 232 |
message generated when writing to a missing page on file typed memories, |
| 233 |
as long as the page range was write-protected before. Such a message will |
| 234 |
not be generated on anonymous memories by default. |
| 235 |
|
| 236 |
If the application wants to be able to write protect none ptes on anonymous |
| 237 |
memory, one can pre-populate the memory with e.g. MADV_POPULATE_READ. On |
| 238 |
newer kernels, one can also detect the feature UFFD_FEATURE_WP_UNPOPULATED |
| 239 |
and set the feature bit in advance to make sure none ptes will also be |
| 240 |
write protected even upon anonymous memory. |
| 241 |
|
| 242 |
When using ``UFFDIO_REGISTER_MODE_WP`` in combination with either |
| 243 |
``UFFDIO_REGISTER_MODE_MISSING`` or ``UFFDIO_REGISTER_MODE_MINOR``, when |
| 244 |
resolving missing / minor faults with ``UFFDIO_COPY`` or ``UFFDIO_CONTINUE`` |
| 245 |
respectively, it may be desirable for the new page / mapping to be |
| 246 |
write-protected (so future writes will also result in a WP fault). These ioctls |
| 247 |
support a mode flag (``UFFDIO_COPY_MODE_WP`` or ``UFFDIO_CONTINUE_MODE_WP`` |
| 248 |
respectively) to configure the mapping this way. |
| 249 |
|
| 250 |
If the userfaultfd context has ``UFFD_FEATURE_WP_ASYNC`` feature bit set, |
| 251 |
any vma registered with write-protection will work in async mode rather |
| 252 |
than the default sync mode. |
| 253 |
|
| 254 |
In async mode, there will be no message generated when a write operation |
| 255 |
happens, meanwhile the write-protection will be resolved automatically by |
| 256 |
the kernel. It can be seen as a more accurate version of soft-dirty |
| 257 |
tracking and it can be different in a few ways: |
| 258 |
|
| 259 |
- The dirty result will not be affected by vma changes (e.g. vma |
| 260 |
merging) because the dirty is only tracked by the pte. |
| 261 |
|
| 262 |
- It supports range operations by default, so one can enable tracking on |
| 263 |
any range of memory as long as page aligned. |
| 264 |
|
| 265 |
- Dirty information will not get lost if the pte was zapped due to |
| 266 |
various reasons (e.g. during split of a shmem transparent huge page). |
| 267 |
|
| 268 |
- Due to a reverted meaning of soft-dirty (page clean when uffd-wp bit |
| 269 |
set; dirty when uffd-wp bit cleared), it has different semantics on |
| 270 |
some of the memory operations. For example: ``MADV_DONTNEED`` on |
| 271 |
anonymous (or ``MADV_REMOVE`` on a file mapping) will be treated as |
| 272 |
dirtying of memory by dropping uffd-wp bit during the procedure. |
| 273 |
|
| 274 |
The user app can collect the "written/dirty" status by looking up the |
| 275 |
uffd-wp bit for the pages being interested in /proc/pagemap. |
| 276 |
|
| 277 |
The page will not be under track of uffd-wp async mode until the page is |
| 278 |
explicitly write-protected by ``ioctl(UFFDIO_WRITEPROTECT)`` with the mode |
| 279 |
flag ``UFFDIO_WRITEPROTECT_MODE_WP`` set. Trying to resolve a page fault |
| 280 |
that was tracked by async mode userfaultfd-wp is invalid. |
| 281 |
|
| 282 |
When userfaultfd-wp async mode is used alone, it can be applied to all |
| 283 |
kinds of memory. |
| 284 |
|
| 285 |
Memory Poisioning Emulation |
| 286 |
--------------------------- |
| 287 |
|
| 288 |
In response to a fault (either missing or minor), an action userspace can |
| 289 |
take to "resolve" it is to issue a ``UFFDIO_POISON``. This will cause any |
| 290 |
future faulters to either get a SIGBUS, or in KVM's case the guest will |
| 291 |
receive an MCE as if there were hardware memory poisoning. |
| 292 |
|
| 293 |
This is used to emulate hardware memory poisoning. Imagine a VM running on a |
| 294 |
machine which experiences a real hardware memory error. Later, we live migrate |
| 295 |
the VM to another physical machine. Since we want the migration to be |
| 296 |
transparent to the guest, we want that same address range to act as if it was |
| 297 |
still poisoned, even though it's on a new physical host which ostensibly |
| 298 |
doesn't have a memory error in the exact same spot. |
| 299 |
|
| 300 |
QEMU/KVM |
| 301 |
======== |
| 302 |
|
| 303 |
QEMU/KVM is using the ``userfaultfd`` syscall to implement postcopy live |
| 304 |
migration. Postcopy live migration is one form of memory |
| 305 |
externalization consisting of a virtual machine running with part or |
| 306 |
all of its memory residing on a different node in the cloud. The |
| 307 |
``userfaultfd`` abstraction is generic enough that not a single line of |
| 308 |
KVM kernel code had to be modified in order to add postcopy live |
| 309 |
migration to QEMU. |
| 310 |
|
| 311 |
Guest async page faults, ``FOLL_NOWAIT`` and all other ``GUP*`` features work |
| 312 |
just fine in combination with userfaults. Userfaults trigger async |
| 313 |
page faults in the guest scheduler so those guest processes that |
| 314 |
aren't waiting for userfaults (i.e. network bound) can keep running in |
| 315 |
the guest vcpus. |
| 316 |
|
| 317 |
It is generally beneficial to run one pass of precopy live migration |
| 318 |
just before starting postcopy live migration, in order to avoid |
| 319 |
generating userfaults for readonly guest regions. |
| 320 |
|
| 321 |
The implementation of postcopy live migration currently uses one |
| 322 |
single bidirectional socket but in the future two different sockets |
| 323 |
will be used (to reduce the latency of the userfaults to the minimum |
| 324 |
possible without having to decrease ``/proc/sys/net/ipv4/tcp_wmem``). |
| 325 |
|
| 326 |
The QEMU in the source node writes all pages that it knows are missing |
| 327 |
in the destination node, into the socket, and the migration thread of |
| 328 |
the QEMU running in the destination node runs ``UFFDIO_COPY|ZEROPAGE`` |
| 329 |
ioctls on the ``userfaultfd`` in order to map the received pages into the |
| 330 |
guest (``UFFDIO_ZEROCOPY`` is used if the source page was a zero page). |
| 331 |
|
| 332 |
A different postcopy thread in the destination node listens with |
| 333 |
poll() to the ``userfaultfd`` in parallel. When a ``POLLIN`` event is |
| 334 |
generated after a userfault triggers, the postcopy thread read() from |
| 335 |
the ``userfaultfd`` and receives the fault address (or ``-EAGAIN`` in case the |
| 336 |
userfault was already resolved and waken by a ``UFFDIO_COPY|ZEROPAGE`` run |
| 337 |
by the parallel QEMU migration thread). |
| 338 |
|
| 339 |
After the QEMU postcopy thread (running in the destination node) gets |
| 340 |
the userfault address it writes the information about the missing page |
| 341 |
into the socket. The QEMU source node receives the information and |
| 342 |
roughly "seeks" to that page address and continues sending all |
| 343 |
remaining missing pages from that new page offset. Soon after that |
| 344 |
(just the time to flush the tcp_wmem queue through the network) the |
| 345 |
migration thread in the QEMU running in the destination node will |
| 346 |
receive the page that triggered the userfault and it'll map it as |
| 347 |
usual with the ``UFFDIO_COPY|ZEROPAGE`` (without actually knowing if it |
| 348 |
was spontaneously sent by the source or if it was an urgent page |
| 349 |
requested through a userfault). |
| 350 |
|
| 351 |
By the time the userfaults start, the QEMU in the destination node |
| 352 |
doesn't need to keep any per-page state bitmap relative to the live |
| 353 |
migration around and a single per-page bitmap has to be maintained in |
| 354 |
the QEMU running in the source node to know which pages are still |
| 355 |
missing in the destination node. The bitmap in the source node is |
| 356 |
checked to find which missing pages to send in round robin and we seek |
| 357 |
over it when receiving incoming userfaults. After sending each page of |
| 358 |
course the bitmap is updated accordingly. It's also useful to avoid |
| 359 |
sending the same page twice (in case the userfault is read by the |
| 360 |
postcopy thread just before ``UFFDIO_COPY|ZEROPAGE`` runs in the migration |
| 361 |
thread). |
| 362 |
|
| 363 |
Non-cooperative userfaultfd |
| 364 |
=========================== |
| 365 |
|
| 366 |
When the ``userfaultfd`` is monitored by an external manager, the manager |
| 367 |
must be able to track changes in the process virtual memory |
| 368 |
layout. Userfaultfd can notify the manager about such changes using |
| 369 |
the same read(2) protocol as for the page fault notifications. The |
| 370 |
manager has to explicitly enable these events by setting appropriate |
| 371 |
bits in ``uffdio_api.features`` passed to ``UFFDIO_API`` ioctl: |
| 372 |
|
| 373 |
``UFFD_FEATURE_EVENT_FORK`` |
| 374 |
enable ``userfaultfd`` hooks for fork(). When this feature is |
| 375 |
enabled, the ``userfaultfd`` context of the parent process is |
| 376 |
duplicated into the newly created process. The manager |
| 377 |
receives ``UFFD_EVENT_FORK`` with file descriptor of the new |
| 378 |
``userfaultfd`` context in the ``uffd_msg.fork``. |
| 379 |
|
| 380 |
``UFFD_FEATURE_EVENT_REMAP`` |
| 381 |
enable notifications about mremap() calls. When the |
| 382 |
non-cooperative process moves a virtual memory area to a |
| 383 |
different location, the manager will receive |
| 384 |
``UFFD_EVENT_REMAP``. The ``uffd_msg.remap`` will contain the old and |
| 385 |
new addresses of the area and its original length. |
| 386 |
|
| 387 |
``UFFD_FEATURE_EVENT_REMOVE`` |
| 388 |
enable notifications about madvise(MADV_REMOVE) and |
| 389 |
madvise(MADV_DONTNEED) calls. The event ``UFFD_EVENT_REMOVE`` will |
| 390 |
be generated upon these calls to madvise(). The ``uffd_msg.remove`` |
| 391 |
will contain start and end addresses of the removed area. |
| 392 |
|
| 393 |
``UFFD_FEATURE_EVENT_UNMAP`` |
| 394 |
enable notifications about memory unmapping. The manager will |
| 395 |
get ``UFFD_EVENT_UNMAP`` with ``uffd_msg.remove`` containing start and |
| 396 |
end addresses of the unmapped area. |
| 397 |
|
| 398 |
Although the ``UFFD_FEATURE_EVENT_REMOVE`` and ``UFFD_FEATURE_EVENT_UNMAP`` |
| 399 |
are pretty similar, they quite differ in the action expected from the |
| 400 |
``userfaultfd`` manager. In the former case, the virtual memory is |
| 401 |
removed, but the area is not, the area remains monitored by the |
| 402 |
``userfaultfd``, and if a page fault occurs in that area it will be |
| 403 |
delivered to the manager. The proper resolution for such page fault is |
| 404 |
to zeromap the faulting address. However, in the latter case, when an |
| 405 |
area is unmapped, either explicitly (with munmap() system call), or |
| 406 |
implicitly (e.g. during mremap()), the area is removed and in turn the |
| 407 |
``userfaultfd`` context for such area disappears too and the manager will |
| 408 |
not get further userland page faults from the removed area. Still, the |
| 409 |
notification is required in order to prevent manager from using |
| 410 |
``UFFDIO_COPY`` on the unmapped area. |
| 411 |
|
| 412 |
Unlike userland page faults which have to be synchronous and require |
| 413 |
explicit or implicit wakeup, all the events are delivered |
| 414 |
asynchronously and the non-cooperative process resumes execution as |
| 415 |
soon as manager executes read(). The ``userfaultfd`` manager should |
| 416 |
carefully synchronize calls to ``UFFDIO_COPY`` with the events |
| 417 |
processing. To aid the synchronization, the ``UFFDIO_COPY`` ioctl will |
| 418 |
return ``-ENOSPC`` when the monitored process exits at the time of |
| 419 |
``UFFDIO_COPY``, and ``-ENOENT``, when the non-cooperative process has changed |
| 420 |
its virtual memory layout simultaneously with outstanding ``UFFDIO_COPY`` |
| 421 |
operation. |
| 422 |
|
| 423 |
The current asynchronous model of the event delivery is optimal for |
| 424 |
single threaded non-cooperative ``userfaultfd`` manager implementations. A |
| 425 |
synchronous event delivery model can be added later as a new |
| 426 |
``userfaultfd`` feature to facilitate multithreading enhancements of the |
| 427 |
non cooperative manager, for example to allow ``UFFDIO_COPY`` ioctls to |
| 428 |
run in parallel to the event reception. Single threaded |
| 429 |
implementations should continue to use the current async event |
| 430 |
delivery model instead. |