msync.c 2.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/mm/msync.c
  4. *
  5. * Copyright (C) 1994-1999 Linus Torvalds
  6. */
  7. /*
  8. * The msync() system call.
  9. */
  10. #include <linux/fs.h>
  11. #include <linux/mm.h>
  12. #include <linux/mman.h>
  13. #include <linux/file.h>
  14. #include <linux/syscalls.h>
  15. #include <linux/sched.h>
  16. /*
  17. * MS_SYNC syncs the entire file - including mappings.
  18. *
  19. * MS_ASYNC does not start I/O (it used to, up to 2.5.67).
  20. * Nor does it marks the relevant pages dirty (it used to up to 2.6.17).
  21. * Now it doesn't do anything, since dirty pages are properly tracked.
  22. *
  23. * The application may now run fsync() to
  24. * write out the dirty pages and wait on the writeout and check the result.
  25. * Or the application may run fadvise(FADV_DONTNEED) against the fd to start
  26. * async writeout immediately.
  27. * So by _not_ starting I/O in MS_ASYNC we provide complete flexibility to
  28. * applications.
  29. */
  30. SYSCALL_DEFINE3(msync, unsigned long, start, size_t, len, int, flags)
  31. {
  32. unsigned long end;
  33. struct mm_struct *mm = current->mm;
  34. struct vm_area_struct *vma;
  35. int unmapped_error = 0;
  36. int error = -EINVAL;
  37. start = untagged_addr(start);
  38. if (flags & ~(MS_ASYNC | MS_INVALIDATE | MS_SYNC))
  39. goto out;
  40. if (offset_in_page(start))
  41. goto out;
  42. if ((flags & MS_ASYNC) && (flags & MS_SYNC))
  43. goto out;
  44. error = -ENOMEM;
  45. len = (len + ~PAGE_MASK) & PAGE_MASK;
  46. end = start + len;
  47. if (end < start)
  48. goto out;
  49. error = 0;
  50. if (end == start)
  51. goto out;
  52. /*
  53. * If the interval [start,end) covers some unmapped address ranges,
  54. * just ignore them, but return -ENOMEM at the end.
  55. */
  56. mmap_read_lock(mm);
  57. vma = find_vma(mm, start);
  58. for (;;) {
  59. struct file *file;
  60. loff_t fstart, fend;
  61. /* Still start < end. */
  62. error = -ENOMEM;
  63. if (!vma)
  64. goto out_unlock;
  65. /* Here start < vma->vm_end. */
  66. if (start < vma->vm_start) {
  67. start = vma->vm_start;
  68. if (start >= end)
  69. goto out_unlock;
  70. unmapped_error = -ENOMEM;
  71. }
  72. /* Here vma->vm_start <= start < vma->vm_end. */
  73. if ((flags & MS_INVALIDATE) &&
  74. (vma->vm_flags & VM_LOCKED)) {
  75. error = -EBUSY;
  76. goto out_unlock;
  77. }
  78. file = vma->vm_file;
  79. fstart = (start - vma->vm_start) +
  80. ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
  81. fend = fstart + (min(end, vma->vm_end) - start) - 1;
  82. start = vma->vm_end;
  83. if ((flags & MS_SYNC) && file &&
  84. (vma->vm_flags & VM_SHARED)) {
  85. get_file(file);
  86. mmap_read_unlock(mm);
  87. error = vfs_fsync_range(file, fstart, fend, 1);
  88. fput(file);
  89. if (error || start >= end)
  90. goto out;
  91. mmap_read_lock(mm);
  92. vma = find_vma(mm, start);
  93. } else {
  94. if (start >= end) {
  95. error = 0;
  96. goto out_unlock;
  97. }
  98. vma = vma->vm_next;
  99. }
  100. }
  101. out_unlock:
  102. mmap_read_unlock(mm);
  103. out:
  104. return error ? : unmapped_error;
  105. }