mm/mmu_notifier.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/mm/mmu_notifier.c
   4  *
   5  *  Copyright (C) 2008  Qumranet, Inc.
   6  *  Copyright (C) 2008  SGI
   7  *             Christoph Lameter <cl@linux.com>
   8  */
   9
  10 #include <linux/rculist.h>
  11 #include <linux/mmu_notifier.h>
  12 #include <linux/export.h>
  13 #include <linux/mm.h>
  14 #include <linux/err.h>
  15 #include <linux/srcu.h>
  16 #include <linux/rcupdate.h>
  17 #include <linux/sched.h>
  18 #include <linux/sched/mm.h>
  19 #include <linux/slab.h>
  20
  21 /* global SRCU for all MMs */
  22 DEFINE_STATIC_SRCU(srcu);
  23
  24 /*
  25  * This function can't run concurrently against mmu_notifier_register
  26  * because mm->mm_users > 0 during mmu_notifier_register and exit_mmap
  27  * runs with mm_users == 0. Other tasks may still invoke mmu notifiers
  28  * in parallel despite there being no task using this mm any more,
  29  * through the vmas outside of the exit_mmap context, such as with
  30  * vmtruncate. This serializes against mmu_notifier_unregister with
  31  * the mmu_notifier_mm->lock in addition to SRCU and it serializes
  32  * against the other mmu notifiers with SRCU. struct mmu_notifier_mm
  33  * can't go away from under us as exit_mmap holds an mm_count pin
  34  * itself.
  35  */
  36 void __mmu_notifier_release(struct mm_struct *mm)
  37 {
  38         struct mmu_notifier *mn;
  39         int id;
  40
  41         /*
  42          * SRCU here will block mmu_notifier_unregister until
  43          * ->release returns.
  44          */
  45         id = srcu_read_lock(&srcu);
  46         hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist)
  47                 /*
  48                  * If ->release runs before mmu_notifier_unregister it must be
  49                  * handled, as it's the only way for the driver to flush all
  50                  * existing sptes and stop the driver from establishing any more
  51                  * sptes before all the pages in the mm are freed.
  52                  */
  53                 if (mn->ops->release)
  54                         mn->ops->release(mn, mm);
  55
  56         spin_lock(&mm->mmu_notifier_mm->lock);
  57         while (unlikely(!hlist_empty(&mm->mmu_notifier_mm->list))) {
  58                 mn = hlist_entry(mm->mmu_notifier_mm->list.first,
  59                                  struct mmu_notifier,
  60                                  hlist);
  61                 /*
  62                  * We arrived before mmu_notifier_unregister so
  63                  * mmu_notifier_unregister will do nothing other than to wait
  64                  * for ->release to finish and for mmu_notifier_unregister to
  65                  * return.
  66                  */
  67                 hlist_del_init_rcu(&mn->hlist);
  68         }
  69         spin_unlock(&mm->mmu_notifier_mm->lock);
  70         srcu_read_unlock(&srcu, id);
  71
  72         /*
  73          * synchronize_srcu here prevents mmu_notifier_release from returning to
  74          * exit_mmap (which would proceed with freeing all pages in the mm)
  75          * until the ->release method returns, if it was invoked by
  76          * mmu_notifier_unregister.
  77          *
  78          * The mmu_notifier_mm can't go away from under us because one mm_count
  79          * is held by exit_mmap.
  80          */
  81         synchronize_srcu(&srcu);
  82 }
  83
  84 /*
  85  * If no young bitflag is supported by the hardware, ->clear_flush_young can
  86  * unmap the address and return 1 or 0 depending if the mapping previously
  87  * existed or not.
  88  */
  89 int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
  90                                         unsigned long start,
  91                                         unsigned long end)
  92 {
  93         struct mmu_notifier *mn;
  94         int young = 0, id;
  95
  96         id = srcu_read_lock(&srcu);
  97         hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
  98                 if (mn->ops->clear_flush_young)
  99                         young |= mn->ops->clear_flush_young(mn, mm, start, end);
 100         }
 101         srcu_read_unlock(&srcu, id);
 102
 103         return young;
 104 }
 105
 106 int __mmu_notifier_clear_young(struct mm_struct *mm,
 107                                unsigned long start,
 108                                unsigned long end)
 109 {
 110         struct mmu_notifier *mn;
 111         int young = 0, id;
 112
 113         id = srcu_read_lock(&srcu);
 114         hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
 115                 if (mn->ops->clear_young)
 116                         young |= mn->ops->clear_young(mn, mm, start, end);
 117         }
 118         srcu_read_unlock(&srcu, id);
 119
 120         return young;
 121 }
 122
 123 int __mmu_notifier_test_young(struct mm_struct *mm,
 124                               unsigned long address)
 125 {
 126         struct mmu_notifier *mn;
 127         int young = 0, id;
 128
 129         id = srcu_read_lock(&srcu);
 130         hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
 131                 if (mn->ops->test_young) {
 132                         young = mn->ops->test_young(mn, mm, address);
 133                         if (young)
 134                                 break;
 135                 }
 136         }
 137         srcu_read_unlock(&srcu, id);
 138
 139         return young;
 140 }
 141
 142 void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address,
 143                                pte_t pte)
 144 {
 145         struct mmu_notifier *mn;
 146         int id;
 147
 148         id = srcu_read_lock(&srcu);
 149         hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
 150                 if (mn->ops->change_pte)
 151                         mn->ops->change_pte(mn, mm, address, pte);
 152         }
 153         srcu_read_unlock(&srcu, id);
 154 }
 155
 156 int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range)
 157 {
 158         struct mmu_notifier *mn;
 159         int ret = 0;
 160         int id;
 161
 162         id = srcu_read_lock(&srcu);
 163         hlist_for_each_entry_rcu(mn, &range->mm->mmu_notifier_mm->list, hlist) {
 164                 if (mn->ops->invalidate_range_start) {
 165                         int _ret = mn->ops->invalidate_range_start(mn, range);
 166                         if (_ret) {
 167                                 pr_info("%pS callback failed with %d in %sblockable context.\n",
 168                                         mn->ops->invalidate_range_start, _ret,
 169                                         !mmu_notifier_range_blockable(range) ? "non-" : "");
 170                                 WARN_ON(mmu_notifier_range_blockable(range) ||
 171                                         ret != -EAGAIN);
 172                                 ret = _ret;
 173                         }
 174                 }
 175         }
 176         srcu_read_unlock(&srcu, id);
 177
 178         return ret;
 179 }
 180
 181 void __mmu_notifier_invalidate_range_end(struct mmu_notifier_range *range,
 182                                          bool only_end)
 183 {
 184         struct mmu_notifier *mn;
 185         int id;
 186
 187         id = srcu_read_lock(&srcu);
 188         hlist_for_each_entry_rcu(mn, &range->mm->mmu_notifier_mm->list, hlist) {
 189                 /*
 190                  * Call invalidate_range here too to avoid the need for the
 191                  * subsystem of having to register an invalidate_range_end
 192                  * call-back when there is invalidate_range already. Usually a
 193                  * subsystem registers either invalidate_range_start()/end() or
 194                  * invalidate_range(), so this will be no additional overhead
 195                  * (besides the pointer check).
 196                  *
 197                  * We skip call to invalidate_range() if we know it is safe ie
 198                  * call site use mmu_notifier_invalidate_range_only_end() which
 199                  * is safe to do when we know that a call to invalidate_range()
 200                  * already happen under page table lock.
 201                  */
 202                 if (!only_end && mn->ops->invalidate_range)
 203                         mn->ops->invalidate_range(mn, range->mm,
 204                                                   range->start,
 205                                                   range->end);
 206                 if (mn->ops->invalidate_range_end)
 207                         mn->ops->invalidate_range_end(mn, range);
 208         }
 209         srcu_read_unlock(&srcu, id);
 210 }
 211
 212 void __mmu_notifier_invalidate_range(struct mm_struct *mm,
 213                                   unsigned long start, unsigned long end)
 214 {
 215         struct mmu_notifier *mn;
 216         int id;
 217
 218         id = srcu_read_lock(&srcu);
 219         hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
 220                 if (mn->ops->invalidate_range)
 221                         mn->ops->invalidate_range(mn, mm, start, end);
 222         }
 223         srcu_read_unlock(&srcu, id);
 224 }
 225
 226 /*
 227  * Same as mmu_notifier_register but here the caller must hold the
 228  * mmap_sem in write mode.
 229  */
 230 int __mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm)
 231 {
 232         struct mmu_notifier_mm *mmu_notifier_mm = NULL;
 233         int ret;
 234
 235         lockdep_assert_held_write(&mm->mmap_sem);
 236         BUG_ON(atomic_read(&mm->mm_users) <= 0);
 237
 238         mn->mm = mm;
 239         mn->users = 1;
 240
 241         if (!mm->mmu_notifier_mm) {
 242                 /*
 243                  * kmalloc cannot be called under mm_take_all_locks(), but we
 244                  * know that mm->mmu_notifier_mm can't change while we hold
 245                  * the write side of the mmap_sem.
 246                  */
 247                 mmu_notifier_mm =
 248                         kmalloc(sizeof(struct mmu_notifier_mm), GFP_KERNEL);
 249                 if (!mmu_notifier_mm)
 250                         return -ENOMEM;
 251
 252                 INIT_HLIST_HEAD(&mmu_notifier_mm->list);
 253                 spin_lock_init(&mmu_notifier_mm->lock);
 254         }
 255
 256         ret = mm_take_all_locks(mm);
 257         if (unlikely(ret))
 258                 goto out_clean;
 259
 260         /* Pairs with the mmdrop in mmu_notifier_unregister_* */
 261         mmgrab(mm);
 262
 263         /*
 264          * Serialize the update against mmu_notifier_unregister. A
 265          * side note: mmu_notifier_release can't run concurrently with
 266          * us because we hold the mm_users pin (either implicitly as
 267          * current->mm or explicitly with get_task_mm() or similar).
 268          * We can't race against any other mmu notifier method either
 269          * thanks to mm_take_all_locks().
 270          */
 271         if (mmu_notifier_mm)
 272                 mm->mmu_notifier_mm = mmu_notifier_mm;
 273
 274         spin_lock(&mm->mmu_notifier_mm->lock);
 275         hlist_add_head_rcu(&mn->hlist, &mm->mmu_notifier_mm->list);
 276         spin_unlock(&mm->mmu_notifier_mm->lock);
 277
 278         mm_drop_all_locks(mm);
 279         BUG_ON(atomic_read(&mm->mm_users) <= 0);
 280         return 0;
 281
 282 out_clean:
 283         kfree(mmu_notifier_mm);
 284         return ret;
 285 }
 286 EXPORT_SYMBOL_GPL(__mmu_notifier_register);
 287
 288 /**
 289  * mmu_notifier_register - Register a notifier on a mm
 290  * @mn: The notifier to attach
 291  * @mm: The mm to attach the notifier to
 292  *
 293  * Must not hold mmap_sem nor any other VM related lock when calling
 294  * this registration function. Must also ensure mm_users can't go down
 295  * to zero while this runs to avoid races with mmu_notifier_release,
 296  * so mm has to be current->mm or the mm should be pinned safely such
 297  * as with get_task_mm(). If the mm is not current->mm, the mm_users
 298  * pin should be released by calling mmput after mmu_notifier_register
 299  * returns.
 300  *
 301  * mmu_notifier_unregister() or mmu_notifier_put() must be always called to
 302  * unregister the notifier.
 303  *
 304  * While the caller has a mmu_notifier get the mn->mm pointer will remain
 305  * valid, and can be converted to an active mm pointer via mmget_not_zero().
 306  */
 307 int mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm)
 308 {
 309         int ret;
 310
 311         down_write(&mm->mmap_sem);
 312         ret = __mmu_notifier_register(mn, mm);
 313         up_write(&mm->mmap_sem);
 314         return ret;
 315 }
 316 EXPORT_SYMBOL_GPL(mmu_notifier_register);
 317
 318 static struct mmu_notifier *
 319 find_get_mmu_notifier(struct mm_struct *mm, const struct mmu_notifier_ops *ops)
 320 {
 321         struct mmu_notifier *mn;
 322
 323         spin_lock(&mm->mmu_notifier_mm->lock);
 324         hlist_for_each_entry_rcu (mn, &mm->mmu_notifier_mm->list, hlist) {
 325                 if (mn->ops != ops)
 326                         continue;
 327
 328                 if (likely(mn->users != UINT_MAX))
 329                         mn->users++;
 330                 else
 331                         mn = ERR_PTR(-EOVERFLOW);
 332                 spin_unlock(&mm->mmu_notifier_mm->lock);
 333                 return mn;
 334         }
 335         spin_unlock(&mm->mmu_notifier_mm->lock);
 336         return NULL;
 337 }
 338
 339 /**
 340  * mmu_notifier_get_locked - Return the single struct mmu_notifier for
 341  *                           the mm & ops
 342  * @ops: The operations struct being subscribe with
 343  * @mm : The mm to attach notifiers too
 344  *
 345  * This function either allocates a new mmu_notifier via
 346  * ops->alloc_notifier(), or returns an already existing notifier on the
 347  * list. The value of the ops pointer is used to determine when two notifiers
 348  * are the same.
 349  *
 350  * Each call to mmu_notifier_get() must be paired with a call to
 351  * mmu_notifier_put(). The caller must hold the write side of mm->mmap_sem.
 352  *
 353  * While the caller has a mmu_notifier get the mm pointer will remain valid,
 354  * and can be converted to an active mm pointer via mmget_not_zero().
 355  */
 356 struct mmu_notifier *mmu_notifier_get_locked(const struct mmu_notifier_ops *ops,
 357                                              struct mm_struct *mm)
 358 {
 359         struct mmu_notifier *mn;
 360         int ret;
 361
 362         lockdep_assert_held_write(&mm->mmap_sem);
 363
 364         if (mm->mmu_notifier_mm) {
 365                 mn = find_get_mmu_notifier(mm, ops);
 366                 if (mn)
 367                         return mn;
 368         }
 369
 370         mn = ops->alloc_notifier(mm);
 371         if (IS_ERR(mn))
 372                 return mn;
 373         mn->ops = ops;
 374         ret = __mmu_notifier_register(mn, mm);
 375         if (ret)
 376                 goto out_free;
 377         return mn;
 378 out_free:
 379         mn->ops->free_notifier(mn);
 380         return ERR_PTR(ret);
 381 }
 382 EXPORT_SYMBOL_GPL(mmu_notifier_get_locked);
 383
 384 /* this is called after the last mmu_notifier_unregister() returned */
 385 void __mmu_notifier_mm_destroy(struct mm_struct *mm)
 386 {
 387         BUG_ON(!hlist_empty(&mm->mmu_notifier_mm->list));
 388         kfree(mm->mmu_notifier_mm);
 389         mm->mmu_notifier_mm = LIST_POISON1; /* debug */
 390 }
 391
 392 /*
 393  * This releases the mm_count pin automatically and frees the mm
 394  * structure if it was the last user of it. It serializes against
 395  * running mmu notifiers with SRCU and against mmu_notifier_unregister
 396  * with the unregister lock + SRCU. All sptes must be dropped before
 397  * calling mmu_notifier_unregister. ->release or any other notifier
 398  * method may be invoked concurrently with mmu_notifier_unregister,
 399  * and only after mmu_notifier_unregister returned we're guaranteed
 400  * that ->release or any other method can't run anymore.
 401  */
 402 void mmu_notifier_unregister(struct mmu_notifier *mn, struct mm_struct *mm)
 403 {
 404         BUG_ON(atomic_read(&mm->mm_count) <= 0);
 405
 406         if (!hlist_unhashed(&mn->hlist)) {
 407                 /*
 408                  * SRCU here will force exit_mmap to wait for ->release to
 409                  * finish before freeing the pages.
 410                  */
 411                 int id;
 412
 413                 id = srcu_read_lock(&srcu);
 414                 /*
 415                  * exit_mmap will block in mmu_notifier_release to guarantee
 416                  * that ->release is called before freeing the pages.
 417                  */
 418                 if (mn->ops->release)
 419                         mn->ops->release(mn, mm);
 420                 srcu_read_unlock(&srcu, id);
 421
 422                 spin_lock(&mm->mmu_notifier_mm->lock);
 423                 /*
 424                  * Can not use list_del_rcu() since __mmu_notifier_release
 425                  * can delete it before we hold the lock.
 426                  */
 427                 hlist_del_init_rcu(&mn->hlist);
 428                 spin_unlock(&mm->mmu_notifier_mm->lock);
 429         }
 430
 431         /*
 432          * Wait for any running method to finish, of course including
 433          * ->release if it was run by mmu_notifier_release instead of us.
 434          */
 435         synchronize_srcu(&srcu);
 436
 437         BUG_ON(atomic_read(&mm->mm_count) <= 0);
 438
 439         mmdrop(mm);
 440 }
 441 EXPORT_SYMBOL_GPL(mmu_notifier_unregister);
 442
 443 static void mmu_notifier_free_rcu(struct rcu_head *rcu)
 444 {
 445         struct mmu_notifier *mn = container_of(rcu, struct mmu_notifier, rcu);
 446         struct mm_struct *mm = mn->mm;
 447
 448         mn->ops->free_notifier(mn);
 449         /* Pairs with the get in __mmu_notifier_register() */
 450         mmdrop(mm);
 451 }
 452
 453 /**
 454  * mmu_notifier_put - Release the reference on the notifier
 455  * @mn: The notifier to act on
 456  *
 457  * This function must be paired with each mmu_notifier_get(), it releases the
 458  * reference obtained by the get. If this is the last reference then process
 459  * to free the notifier will be run asynchronously.
 460  *
 461  * Unlike mmu_notifier_unregister() the get/put flow only calls ops->release
 462  * when the mm_struct is destroyed. Instead free_notifier is always called to
 463  * release any resources held by the user.
 464  *
 465  * As ops->release is not guaranteed to be called, the user must ensure that
 466  * all sptes are dropped, and no new sptes can be established before
 467  * mmu_notifier_put() is called.
 468  *
 469  * This function can be called from the ops->release callback, however the
 470  * caller must still ensure it is called pairwise with mmu_notifier_get().
 471  *
 472  * Modules calling this function must call mmu_notifier_synchronize() in
 473  * their __exit functions to ensure the async work is completed.
 474  */
 475 void mmu_notifier_put(struct mmu_notifier *mn)
 476 {
 477         struct mm_struct *mm = mn->mm;
 478
 479         spin_lock(&mm->mmu_notifier_mm->lock);
 480         if (WARN_ON(!mn->users) || --mn->users)
 481                 goto out_unlock;
 482         hlist_del_init_rcu(&mn->hlist);
 483         spin_unlock(&mm->mmu_notifier_mm->lock);
 484
 485         call_srcu(&srcu, &mn->rcu, mmu_notifier_free_rcu);
 486         return;
 487
 488 out_unlock:
 489         spin_unlock(&mm->mmu_notifier_mm->lock);
 490 }
 491 EXPORT_SYMBOL_GPL(mmu_notifier_put);
 492
 493 /**
 494  * mmu_notifier_synchronize - Ensure all mmu_notifiers are freed
 495  *
 496  * This function ensures that all outstanding async SRU work from
 497  * mmu_notifier_put() is completed. After it returns any mmu_notifier_ops
 498  * associated with an unused mmu_notifier will no longer be called.
 499  *
 500  * Before using the caller must ensure that all of its mmu_notifiers have been
 501  * fully released via mmu_notifier_put().
 502  *
 503  * Modules using the mmu_notifier_put() API should call this in their __exit
 504  * function to avoid module unloading races.
 505  */
 506 void mmu_notifier_synchronize(void)
 507 {
 508         synchronize_srcu(&srcu);
 509 }
 510 EXPORT_SYMBOL_GPL(mmu_notifier_synchronize);
 511
 512 bool
 513 mmu_notifier_range_update_to_read_only(const struct mmu_notifier_range *range)
 514 {
 515         if (!range->vma || range->event != MMU_NOTIFY_PROTECTION_VMA)
 516                 return false;
 517         /* Return true if the vma still have the read flag set. */
 518         return range->vma->vm_flags & VM_READ;
 519 }
 520 EXPORT_SYMBOL_GPL(mmu_notifier_range_update_to_read_only);