[linux.git] / mm / msync.c

// SPDX-License-Identifier: GPL-2.0
/*
 *	linux/mm/msync.c
 *
 * Copyright (C) 1994-1999  Linus Torvalds
 */

/*
 * The msync() system call.
 */
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/file.h>
#include <linux/syscalls.h>
#include <linux/sched.h>

/*
 * MS_SYNC syncs the entire file - including mappings.
 *
 * MS_ASYNC does not start I/O (it used to, up to 2.5.67).
 * Nor does it marks the relevant pages dirty (it used to up to 2.6.17).
 * Now it doesn't do anything, since dirty pages are properly tracked.
 *
 * The application may now run fsync() to
 * write out the dirty pages and wait on the writeout and check the result.
 * Or the application may run fadvise(FADV_DONTNEED) against the fd to start
 * async writeout immediately.
 * So by _not_ starting I/O in MS_ASYNC we provide complete flexibility to
 * applications.
 */
SYSCALL_DEFINE3(msync, unsigned long, start, size_t, len, int, flags)
{
	unsigned long end;
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	int unmapped_error = 0;
	int error = -EINVAL;

	start = untagged_addr(start);

	if (flags & ~(MS_ASYNC | MS_INVALIDATE | MS_SYNC))
		goto out;
	if (offset_in_page(start))
		goto out;
	if ((flags & MS_ASYNC) && (flags & MS_SYNC))
		goto out;
	error = -ENOMEM;
	len = (len + ~PAGE_MASK) & PAGE_MASK;
	end = start + len;
	if (end < start)
		goto out;
	error = 0;
	if (end == start)
		goto out;
	/*
	 * If the interval [start,end) covers some unmapped address ranges,
	 * just ignore them, but return -ENOMEM at the end. Besides, if the
	 * flag is MS_ASYNC (w/o MS_INVALIDATE) the result would be -ENOMEM
	 * anyway and there is nothing left to do, so return immediately.
	 */
	mmap_read_lock(mm);
	vma = find_vma(mm, start);
	for (;;) {
		struct file *file;
		loff_t fstart, fend;

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