include/linux/mmu_notifier.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_MMU_NOTIFIER_H
   3 #define _LINUX_MMU_NOTIFIER_H
   4
   5 #include <linux/types.h>
   6 #include <linux/list.h>
   7 #include <linux/spinlock.h>
   8 #include <linux/mm_types.h>
   9 #include <linux/srcu.h>
  10
  11 struct mmu_notifier;
  12 struct mmu_notifier_ops;
  13
  14 /* mmu_notifier_ops flags */
  15 #define MMU_INVALIDATE_DOES_NOT_BLOCK   (0x01)
  16
  17 #ifdef CONFIG_MMU_NOTIFIER
  18
  19 /*
  20  * The mmu notifier_mm structure is allocated and installed in
  21  * mm->mmu_notifier_mm inside the mm_take_all_locks() protected
  22  * critical section and it's released only when mm_count reaches zero
  23  * in mmdrop().
  24  */
  25 struct mmu_notifier_mm {
  26         /* all mmu notifiers registerd in this mm are queued in this list */
  27         struct hlist_head list;
  28         /* to serialize the list modifications and hlist_unhashed */
  29         spinlock_t lock;
  30 };
  31
  32 struct mmu_notifier_ops {
  33         /*
  34          * Flags to specify behavior of callbacks for this MMU notifier.
  35          * Used to determine which context an operation may be called.
  36          *
  37          * MMU_INVALIDATE_DOES_NOT_BLOCK: invalidate_range_* callbacks do not
  38          *      block
  39          */
  40         int flags;
  41
  42         /*
  43          * Called either by mmu_notifier_unregister or when the mm is
  44          * being destroyed by exit_mmap, always before all pages are
  45          * freed. This can run concurrently with other mmu notifier
  46          * methods (the ones invoked outside the mm context) and it
  47          * should tear down all secondary mmu mappings and freeze the
  48          * secondary mmu. If this method isn't implemented you've to
  49          * be sure that nothing could possibly write to the pages
  50          * through the secondary mmu by the time the last thread with
  51          * tsk->mm == mm exits.
  52          *
  53          * As side note: the pages freed after ->release returns could
  54          * be immediately reallocated by the gart at an alias physical
  55          * address with a different cache model, so if ->release isn't
  56          * implemented because all _software_ driven memory accesses
  57          * through the secondary mmu are terminated by the time the
  58          * last thread of this mm quits, you've also to be sure that
  59          * speculative _hardware_ operations can't allocate dirty
  60          * cachelines in the cpu that could not be snooped and made
  61          * coherent with the other read and write operations happening
  62          * through the gart alias address, so leading to memory
  63          * corruption.
  64          */
  65         void (*release)(struct mmu_notifier *mn,
  66                         struct mm_struct *mm);
  67
  68         /*
  69          * clear_flush_young is called after the VM is
  70          * test-and-clearing the young/accessed bitflag in the
  71          * pte. This way the VM will provide proper aging to the
  72          * accesses to the page through the secondary MMUs and not
  73          * only to the ones through the Linux pte.
  74          * Start-end is necessary in case the secondary MMU is mapping the page
  75          * at a smaller granularity than the primary MMU.
  76          */
  77         int (*clear_flush_young)(struct mmu_notifier *mn,
  78                                  struct mm_struct *mm,
  79                                  unsigned long start,
  80                                  unsigned long end);
  81
  82         /*
  83          * clear_young is a lightweight version of clear_flush_young. Like the
  84          * latter, it is supposed to test-and-clear the young/accessed bitflag
  85          * in the secondary pte, but it may omit flushing the secondary tlb.
  86          */
  87         int (*clear_young)(struct mmu_notifier *mn,
  88                            struct mm_struct *mm,
  89                            unsigned long start,
  90                            unsigned long end);
  91
  92         /*
  93          * test_young is called to check the young/accessed bitflag in
  94          * the secondary pte. This is used to know if the page is
  95          * frequently used without actually clearing the flag or tearing
  96          * down the secondary mapping on the page.
  97          */
  98         int (*test_young)(struct mmu_notifier *mn,
  99                           struct mm_struct *mm,
 100                           unsigned long address);
 101
 102         /*
 103          * change_pte is called in cases that pte mapping to page is changed:
 104          * for example, when ksm remaps pte to point to a new shared page.
 105          */
 106         void (*change_pte)(struct mmu_notifier *mn,
 107                            struct mm_struct *mm,
 108                            unsigned long address,
 109                            pte_t pte);
 110
 111         /*
 112          * invalidate_range_start() and invalidate_range_end() must be
 113          * paired and are called only when the mmap_sem and/or the
 114          * locks protecting the reverse maps are held. If the subsystem
 115          * can't guarantee that no additional references are taken to
 116          * the pages in the range, it has to implement the
 117          * invalidate_range() notifier to remove any references taken
 118          * after invalidate_range_start().
 119          *
 120          * Invalidation of multiple concurrent ranges may be
 121          * optionally permitted by the driver. Either way the
 122          * establishment of sptes is forbidden in the range passed to
 123          * invalidate_range_begin/end for the whole duration of the
 124          * invalidate_range_begin/end critical section.
 125          *
 126          * invalidate_range_start() is called when all pages in the
 127          * range are still mapped and have at least a refcount of one.
 128          *
 129          * invalidate_range_end() is called when all pages in the
 130          * range have been unmapped and the pages have been freed by
 131          * the VM.
 132          *
 133          * The VM will remove the page table entries and potentially
 134          * the page between invalidate_range_start() and
 135          * invalidate_range_end(). If the page must not be freed
 136          * because of pending I/O or other circumstances then the
 137          * invalidate_range_start() callback (or the initial mapping
 138          * by the driver) must make sure that the refcount is kept
 139          * elevated.
 140          *
 141          * If the driver increases the refcount when the pages are
 142          * initially mapped into an address space then either
 143          * invalidate_range_start() or invalidate_range_end() may
 144          * decrease the refcount. If the refcount is decreased on
 145          * invalidate_range_start() then the VM can free pages as page
 146          * table entries are removed.  If the refcount is only
 147          * droppped on invalidate_range_end() then the driver itself
 148          * will drop the last refcount but it must take care to flush
 149          * any secondary tlb before doing the final free on the
 150          * page. Pages will no longer be referenced by the linux
 151          * address space but may still be referenced by sptes until
 152          * the last refcount is dropped.
 153          *
 154          * If blockable argument is set to false then the callback cannot
 155          * sleep and has to return with -EAGAIN. 0 should be returned
 156          * otherwise. Please note that if invalidate_range_start approves
 157          * a non-blocking behavior then the same applies to
 158          * invalidate_range_end.
 159          *
 160          */
 161         int (*invalidate_range_start)(struct mmu_notifier *mn,
 162                                        struct mm_struct *mm,
 163                                        unsigned long start, unsigned long end,
 164                                        bool blockable);
 165         void (*invalidate_range_end)(struct mmu_notifier *mn,
 166                                      struct mm_struct *mm,
 167                                      unsigned long start, unsigned long end);
 168
 169         /*
 170          * invalidate_range() is either called between
 171          * invalidate_range_start() and invalidate_range_end() when the
 172          * VM has to free pages that where unmapped, but before the
 173          * pages are actually freed, or outside of _start()/_end() when
 174          * a (remote) TLB is necessary.
 175          *
 176          * If invalidate_range() is used to manage a non-CPU TLB with
 177          * shared page-tables, it not necessary to implement the
 178          * invalidate_range_start()/end() notifiers, as
 179          * invalidate_range() alread catches the points in time when an
 180          * external TLB range needs to be flushed. For more in depth
 181          * discussion on this see Documentation/vm/mmu_notifier.rst
 182          *
 183          * Note that this function might be called with just a sub-range
 184          * of what was passed to invalidate_range_start()/end(), if
 185          * called between those functions.
 186          *
 187          * If this callback cannot block, and invalidate_range_{start,end}
 188          * cannot block, mmu_notifier_ops.flags should have
 189          * MMU_INVALIDATE_DOES_NOT_BLOCK set.
 190          */
 191         void (*invalidate_range)(struct mmu_notifier *mn, struct mm_struct *mm,
 192                                  unsigned long start, unsigned long end);
 193 };
 194
 195 /*
 196  * The notifier chains are protected by mmap_sem and/or the reverse map
 197  * semaphores. Notifier chains are only changed when all reverse maps and
 198  * the mmap_sem locks are taken.
 199  *
 200  * Therefore notifier chains can only be traversed when either
 201  *
 202  * 1. mmap_sem is held.
 203  * 2. One of the reverse map locks is held (i_mmap_rwsem or anon_vma->rwsem).
 204  * 3. No other concurrent thread can access the list (release)
 205  */
 206 struct mmu_notifier {
 207         struct hlist_node hlist;
 208         const struct mmu_notifier_ops *ops;
 209 };
 210
 211 static inline int mm_has_notifiers(struct mm_struct *mm)
 212 {
 213         return unlikely(mm->mmu_notifier_mm);
 214 }
 215
 216 extern int mmu_notifier_register(struct mmu_notifier *mn,
 217                                  struct mm_struct *mm);
 218 extern int __mmu_notifier_register(struct mmu_notifier *mn,
 219                                    struct mm_struct *mm);
 220 extern void mmu_notifier_unregister(struct mmu_notifier *mn,
 221                                     struct mm_struct *mm);
 222 extern void mmu_notifier_unregister_no_release(struct mmu_notifier *mn,
 223                                                struct mm_struct *mm);
 224 extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);
 225 extern void __mmu_notifier_release(struct mm_struct *mm);
 226 extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
 227                                           unsigned long start,
 228                                           unsigned long end);
 229 extern int __mmu_notifier_clear_young(struct mm_struct *mm,
 230                                       unsigned long start,
 231                                       unsigned long end);
 232 extern int __mmu_notifier_test_young(struct mm_struct *mm,
 233                                      unsigned long address);
 234 extern void __mmu_notifier_change_pte(struct mm_struct *mm,
 235                                       unsigned long address, pte_t pte);
 236 extern int __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
 237                                   unsigned long start, unsigned long end,
 238                                   bool blockable);
 239 extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
 240                                   unsigned long start, unsigned long end,
 241                                   bool only_end);
 242 extern void __mmu_notifier_invalidate_range(struct mm_struct *mm,
 243                                   unsigned long start, unsigned long end);
 244 extern bool mm_has_blockable_invalidate_notifiers(struct mm_struct *mm);
 245
 246 static inline void mmu_notifier_release(struct mm_struct *mm)
 247 {
 248         if (mm_has_notifiers(mm))
 249                 __mmu_notifier_release(mm);
 250 }
 251
 252 static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
 253                                           unsigned long start,
 254                                           unsigned long end)
 255 {
 256         if (mm_has_notifiers(mm))
 257                 return __mmu_notifier_clear_flush_young(mm, start, end);
 258         return 0;
 259 }
 260
 261 static inline int mmu_notifier_clear_young(struct mm_struct *mm,
 262                                            unsigned long start,
 263                                            unsigned long end)
 264 {
 265         if (mm_has_notifiers(mm))
 266                 return __mmu_notifier_clear_young(mm, start, end);
 267         return 0;
 268 }
 269
 270 static inline int mmu_notifier_test_young(struct mm_struct *mm,
 271                                           unsigned long address)
 272 {
 273         if (mm_has_notifiers(mm))
 274                 return __mmu_notifier_test_young(mm, address);
 275         return 0;
 276 }
 277
 278 static inline void mmu_notifier_change_pte(struct mm_struct *mm,
 279                                            unsigned long address, pte_t pte)
 280 {
 281         if (mm_has_notifiers(mm))
 282                 __mmu_notifier_change_pte(mm, address, pte);
 283 }
 284
 285 static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
 286                                   unsigned long start, unsigned long end)
 287 {
 288         if (mm_has_notifiers(mm))
 289                 __mmu_notifier_invalidate_range_start(mm, start, end, true);
 290 }
 291
 292 static inline int mmu_notifier_invalidate_range_start_nonblock(struct mm_struct *mm,
 293                                   unsigned long start, unsigned long end)
 294 {
 295         if (mm_has_notifiers(mm))
 296                 return __mmu_notifier_invalidate_range_start(mm, start, end, false);
 297         return 0;
 298 }
 299
 300 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
 301                                   unsigned long start, unsigned long end)
 302 {
 303         if (mm_has_notifiers(mm))
 304                 __mmu_notifier_invalidate_range_end(mm, start, end, false);
 305 }
 306
 307 static inline void mmu_notifier_invalidate_range_only_end(struct mm_struct *mm,
 308                                   unsigned long start, unsigned long end)
 309 {
 310         if (mm_has_notifiers(mm))
 311                 __mmu_notifier_invalidate_range_end(mm, start, end, true);
 312 }
 313
 314 static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
 315                                   unsigned long start, unsigned long end)
 316 {
 317         if (mm_has_notifiers(mm))
 318                 __mmu_notifier_invalidate_range(mm, start, end);
 319 }
 320
 321 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
 322 {
 323         mm->mmu_notifier_mm = NULL;
 324 }
 325
 326 static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
 327 {
 328         if (mm_has_notifiers(mm))
 329                 __mmu_notifier_mm_destroy(mm);
 330 }
 331
 332 #define ptep_clear_flush_young_notify(__vma, __address, __ptep)         \
 333 ({                                                                      \
 334         int __young;                                                    \
 335         struct vm_area_struct *___vma = __vma;                          \
 336         unsigned long ___address = __address;                           \
 337         __young = ptep_clear_flush_young(___vma, ___address, __ptep);   \
 338         __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
 339                                                   ___address,           \
 340                                                   ___address +          \
 341                                                         PAGE_SIZE);     \
 342         __young;                                                        \
 343 })
 344
 345 #define pmdp_clear_flush_young_notify(__vma, __address, __pmdp)         \
 346 ({                                                                      \
 347         int __young;                                                    \
 348         struct vm_area_struct *___vma = __vma;                          \
 349         unsigned long ___address = __address;                           \
 350         __young = pmdp_clear_flush_young(___vma, ___address, __pmdp);   \
 351         __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
 352                                                   ___address,           \
 353                                                   ___address +          \
 354                                                         PMD_SIZE);      \
 355         __young;                                                        \
 356 })
 357
 358 #define ptep_clear_young_notify(__vma, __address, __ptep)               \
 359 ({                                                                      \
 360         int __young;                                                    \
 361         struct vm_area_struct *___vma = __vma;                          \
 362         unsigned long ___address = __address;                           \
 363         __young = ptep_test_and_clear_young(___vma, ___address, __ptep);\
 364         __young |= mmu_notifier_clear_young(___vma->vm_mm, ___address,  \
 365                                             ___address + PAGE_SIZE);    \
 366         __young;                                                        \
 367 })
 368
 369 #define pmdp_clear_young_notify(__vma, __address, __pmdp)               \
 370 ({                                                                      \
 371         int __young;                                                    \
 372         struct vm_area_struct *___vma = __vma;                          \
 373         unsigned long ___address = __address;                           \
 374         __young = pmdp_test_and_clear_young(___vma, ___address, __pmdp);\
 375         __young |= mmu_notifier_clear_young(___vma->vm_mm, ___address,  \
 376                                             ___address + PMD_SIZE);     \
 377         __young;                                                        \
 378 })
 379
 380 #define ptep_clear_flush_notify(__vma, __address, __ptep)               \
 381 ({                                                                      \
 382         unsigned long ___addr = __address & PAGE_MASK;                  \
 383         struct mm_struct *___mm = (__vma)->vm_mm;                       \
 384         pte_t ___pte;                                                   \
 385                                                                         \
 386         ___pte = ptep_clear_flush(__vma, __address, __ptep);            \
 387         mmu_notifier_invalidate_range(___mm, ___addr,                   \
 388                                         ___addr + PAGE_SIZE);           \
 389                                                                         \
 390         ___pte;                                                         \
 391 })
 392
 393 #define pmdp_huge_clear_flush_notify(__vma, __haddr, __pmd)             \
 394 ({                                                                      \
 395         unsigned long ___haddr = __haddr & HPAGE_PMD_MASK;              \
 396         struct mm_struct *___mm = (__vma)->vm_mm;                       \
 397         pmd_t ___pmd;                                                   \
 398                                                                         \
 399         ___pmd = pmdp_huge_clear_flush(__vma, __haddr, __pmd);          \
 400         mmu_notifier_invalidate_range(___mm, ___haddr,                  \
 401                                       ___haddr + HPAGE_PMD_SIZE);       \
 402                                                                         \
 403         ___pmd;                                                         \
 404 })
 405
 406 #define pudp_huge_clear_flush_notify(__vma, __haddr, __pud)             \
 407 ({                                                                      \
 408         unsigned long ___haddr = __haddr & HPAGE_PUD_MASK;              \
 409         struct mm_struct *___mm = (__vma)->vm_mm;                       \
 410         pud_t ___pud;                                                   \
 411                                                                         \
 412         ___pud = pudp_huge_clear_flush(__vma, __haddr, __pud);          \
 413         mmu_notifier_invalidate_range(___mm, ___haddr,                  \
 414                                       ___haddr + HPAGE_PUD_SIZE);       \
 415                                                                         \
 416         ___pud;                                                         \
 417 })
 418
 419 /*
 420  * set_pte_at_notify() sets the pte _after_ running the notifier.
 421  * This is safe to start by updating the secondary MMUs, because the primary MMU
 422  * pte invalidate must have already happened with a ptep_clear_flush() before
 423  * set_pte_at_notify() has been invoked.  Updating the secondary MMUs first is
 424  * required when we change both the protection of the mapping from read-only to
 425  * read-write and the pfn (like during copy on write page faults). Otherwise the
 426  * old page would remain mapped readonly in the secondary MMUs after the new
 427  * page is already writable by some CPU through the primary MMU.
 428  */
 429 #define set_pte_at_notify(__mm, __address, __ptep, __pte)               \
 430 ({                                                                      \
 431         struct mm_struct *___mm = __mm;                                 \
 432         unsigned long ___address = __address;                           \
 433         pte_t ___pte = __pte;                                           \
 434                                                                         \
 435         mmu_notifier_change_pte(___mm, ___address, ___pte);             \
 436         set_pte_at(___mm, ___address, __ptep, ___pte);                  \
 437 })
 438
 439 extern void mmu_notifier_call_srcu(struct rcu_head *rcu,
 440                                    void (*func)(struct rcu_head *rcu));
 441 extern void mmu_notifier_synchronize(void);
 442
 443 #else /* CONFIG_MMU_NOTIFIER */
 444
 445 static inline int mm_has_notifiers(struct mm_struct *mm)
 446 {
 447         return 0;
 448 }
 449
 450 static inline void mmu_notifier_release(struct mm_struct *mm)
 451 {
 452 }
 453
 454 static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
 455                                           unsigned long start,
 456                                           unsigned long end)
 457 {
 458         return 0;
 459 }
 460
 461 static inline int mmu_notifier_test_young(struct mm_struct *mm,
 462                                           unsigned long address)
 463 {
 464         return 0;
 465 }
 466
 467 static inline void mmu_notifier_change_pte(struct mm_struct *mm,
 468                                            unsigned long address, pte_t pte)
 469 {
 470 }
 471
 472 static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
 473                                   unsigned long start, unsigned long end)
 474 {
 475 }
 476
 477 static inline int mmu_notifier_invalidate_range_start_nonblock(struct mm_struct *mm,
 478                                   unsigned long start, unsigned long end)
 479 {
 480         return 0;
 481 }
 482
 483 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
 484                                   unsigned long start, unsigned long end)
 485 {
 486 }
 487
 488 static inline void mmu_notifier_invalidate_range_only_end(struct mm_struct *mm,
 489                                   unsigned long start, unsigned long end)
 490 {
 491 }
 492
 493 static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
 494                                   unsigned long start, unsigned long end)
 495 {
 496 }
 497
 498 static inline bool mm_has_blockable_invalidate_notifiers(struct mm_struct *mm)
 499 {
 500         return false;
 501 }
 502
 503 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
 504 {
 505 }
 506
 507 static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
 508 {
 509 }
 510
 511 #define ptep_clear_flush_young_notify ptep_clear_flush_young
 512 #define pmdp_clear_flush_young_notify pmdp_clear_flush_young
 513 #define ptep_clear_young_notify ptep_test_and_clear_young
 514 #define pmdp_clear_young_notify pmdp_test_and_clear_young
 515 #define ptep_clear_flush_notify ptep_clear_flush
 516 #define pmdp_huge_clear_flush_notify pmdp_huge_clear_flush
 517 #define pudp_huge_clear_flush_notify pudp_huge_clear_flush
 518 #define set_pte_at_notify set_pte_at
 519
 520 #endif /* CONFIG_MMU_NOTIFIER */
 521
 522 #endif /* _LINUX_MMU_NOTIFIER_H */