1 files changed, 86 insertions, 104 deletions
diff --git a/mm/mincore.c b/mm/mincore.c
index 72890780c1c9..b44d7f875cb6 100644
--- a/mm/mincore.c
+++ b/mm/mincore.c
@@ -1,7 +1,7 @@
 /*
 *      linux/mm/mincore.c
 *
- * Copyright (C) 1994-1999  Linus Torvalds
+ * Copyright (C) 1994-2006  Linus Torvalds
 */
 /*
@@ -38,46 +38,60 @@ static unsigned char mincore_page(struct vm_area_struct * vma,
        return present;
 }
-static long mincore_vma(struct vm_area_struct * vma,
+/*
-        unsigned long start, unsigned long end, unsigned char __user * vec)
+ * Do a chunk of "sys_mincore()". We've already checked
+ * all the arguments, we hold the mmap semaphore: we should
+ * just return the amount of info we're asked for.
+ */
+static long do_mincore(unsigned long addr, unsigned char *vec, unsigned long pages)
 {
-        long error, i, remaining;
+        unsigned long i, nr, pgoff;
-        unsigned char * tmp;
+        struct vm_area_struct *vma = find_vma(current->mm, addr);
-        error = -ENOMEM;
+        /*
-        if (!vma->vm_file)
+         * find_vma() didn't find anything: the address
-                return error;
+         * is above everything we have mapped.
+         */
-        start = ((start - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
+        if (!vma) {
-        if (end > vma->vm_end)
+                memset(vec, 0, pages);
-                end = vma->vm_end;
+                return pages;
-        end = ((end - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
+        }
-        error = -EAGAIN;
+        /*
-        tmp = (unsigned char *) __get_free_page(GFP_KERNEL);
+         * find_vma() found something, but we might be
-        if (!tmp)
+         * below it: check for that.
-                return error;
+         */
+        if (addr < vma->vm_start) {
+                unsigned long gap = (vma->vm_start - addr) >> PAGE_SHIFT;
+                if (gap > pages)
+                        gap = pages;
+                memset(vec, 0, gap);
+                return gap;
+        }
-        /* (end - start) is # of pages, and also # of bytes in "vec */
+        /*
-        remaining = (end - start),
+         * Ok, got it. But check whether it's a segment we support
+         * mincore() on. Right now, we don't do any anonymous mappings.
+         */
+        if (!vma->vm_file)
+                return -ENOMEM;
-        error = 0;
+        /*
-        for (i = 0; remaining > 0; remaining -= PAGE_SIZE, i++) {
+         * Calculate how many pages there are left in the vma, and
-                int j = 0;
+         * what the pgoff is for our address.
-                long thispiece = (remaining < PAGE_SIZE) ?
+         */
-                                                remaining : PAGE_SIZE;
+        nr = (vma->vm_end - addr) >> PAGE_SHIFT;
+        if (nr > pages)
+                nr = pages;
-                while (j < thispiece)
+        pgoff = (addr - vma->vm_start) >> PAGE_SHIFT;
-                        tmp[j++] = mincore_page(vma, start++);
+        pgoff += vma->vm_pgoff;
-                if (copy_to_user(vec + PAGE_SIZE * i, tmp, thispiece)) {
+        /* And then we just fill the sucker in.. */
-                        error = -EFAULT;
+        for (i = 0 ; i < nr; i++, pgoff++)
-                        break;
+                vec[i] = mincore_page(vma, pgoff);
-                }
-        }
-        free_page((unsigned long) tmp);
+        return nr;
-        return error;
 }
 /*
@@ -107,82 +121,50 @@ static long mincore_vma(struct vm_area_struct * vma,
 asmlinkage long sys_mincore(unsigned long start, size_t len,
        unsigned char __user * vec)
 {
-        int index = 0;
+        long retval;
-        unsigned long end, limit;
+        unsigned long pages;
-        struct vm_area_struct * vma;
+        unsigned char *tmp;
-        size_t max;
-        int unmapped_error = 0;
-        long error;
-        /* check the arguments */
-        if (start & ~PAGE_CACHE_MASK)
-                goto einval;
-        limit = TASK_SIZE;
-        if (start >= limit)
-                goto enomem;
-        if (!len)
-                return 0;
-        max = limit - start;
+        /* Check the start address: needs to be page-aligned.. */
-        len = PAGE_CACHE_ALIGN(len);
+        if (start & ~PAGE_CACHE_MASK)
-        if (len > max || !len)
+                return -EINVAL;
-                goto enomem;
-        end = start + len;
-        /* check the output buffer whilst holding the lock */
+        /* ..and we need to be passed a valid user-space range */
-        error = -EFAULT;
+        if (!access_ok(VERIFY_READ, (void __user *) start, len))
-        down_read(&current->mm->mmap_sem);
+                return -ENOMEM;
-        if (!access_ok(VERIFY_WRITE, vec, len >> PAGE_SHIFT))
+        /* This also avoids any overflows on PAGE_CACHE_ALIGN */
-                goto out;
+        pages = len >> PAGE_SHIFT;
+        pages += (len & ~PAGE_MASK) != 0;
-        /*
+        if (!access_ok(VERIFY_WRITE, vec, pages))
-         * If the interval [start,end) covers some unmapped address
+                return -EFAULT;
-         * ranges, just ignore them, but return -ENOMEM at the end.
-         */
-        error = 0;
-        vma = find_vma(current->mm, start);
-        while (vma) {
-                /* Here start < vma->vm_end. */
-                if (start < vma->vm_start) {
-                        unmapped_error = -ENOMEM;
-                        start = vma->vm_start;
-                }
-                /* Here vma->vm_start <= start < vma->vm_end. */
+        tmp = (void *) __get_free_page(GFP_USER);
-                if (end <= vma->vm_end) {
+        if (!tmp)
-                        if (start < end) {
+                return -ENOMEM;
-                                error = mincore_vma(vma, start, end,
-                                                        &vec[index]);
+        retval = 0;
-                                if (error)
+        while (pages) {
-                                        goto out;
+                /*
-                        }
+                 * Do at most PAGE_SIZE entries per iteration, due to
-                        error = unmapped_error;
+                 * the temporary buffer size.
-                        goto out;
+                 */
+                down_read(&current->mm->mmap_sem);
+                retval = do_mincore(start, tmp, max(pages, PAGE_SIZE));
+                up_read(&current->mm->mmap_sem);
+                if (retval <= 0)
+                        break;
+                if (copy_to_user(vec, tmp, retval)) {
+                        retval = -EFAULT;
+                        break;
                }
+                pages -= retval;
-                /* Here vma->vm_start <= start < vma->vm_end < end. */
+                vec += retval;
-                error = mincore_vma(vma, start, vma->vm_end, &vec[index]);
+                start += retval << PAGE_SHIFT;
-                if (error)
+                retval = 0;
-                        goto out;
-                index += (vma->vm_end - start) >> PAGE_CACHE_SHIFT;
-                start = vma->vm_end;
-                vma = vma->vm_next;
        }
+        free_page((unsigned long) tmp);
-        /* we found a hole in the area queried if we arrive here */
+        return retval;
-        error = -ENOMEM;
-out:
-        up_read(&current->mm->mmap_sem);
-        return error;
-einval:
-        return -EINVAL;
-enomem:
-        return -ENOMEM;
 }

diff --git a/mm/mincore.c b/mm/mincore.c index 72890780c1c9..b44d7f875cb6 100644 --- a/mm/mincore.c +++ b/mm/mincore.c
@@ -1,7 +1,7 @@
1	/*	1	/*
2	* linux/mm/mincore.c	2	* linux/mm/mincore.c
3	*	3	*
4	* Copyright (C) 1994-1999 Linus Torvalds	4	* Copyright (C) 1994-2006 Linus Torvalds
5	*/	5	*/
6		6
7	/*	7	/*
@@ -38,46 +38,60 @@ static unsigned char mincore_page(struct vm_area_struct * vma,
38	return present;	38	return present;
39	}	39	}
40		40
41	static long mincore_vma(struct vm_area_struct * vma,	41	/*
42	unsigned long start, unsigned long end, unsigned char __user * vec)	42	* Do a chunk of "sys_mincore()". We've already checked
		43	* all the arguments, we hold the mmap semaphore: we should
		44	* just return the amount of info we're asked for.
		45	*/
		46	static long do_mincore(unsigned long addr, unsigned char *vec, unsigned long pages)
43	{	47	{
44	long error, i, remaining;	48	unsigned long i, nr, pgoff;
45	unsigned char * tmp;	49	struct vm_area_struct *vma = find_vma(current->mm, addr);
46		50
47	error = -ENOMEM;	51	/*
48	if (!vma->vm_file)	52	* find_vma() didn't find anything: the address
49	return error;	53	* is above everything we have mapped.
50		54	*/
51	start = ((start - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;	55	if (!vma) {
52	if (end > vma->vm_end)	56	memset(vec, 0, pages);
53	end = vma->vm_end;	57	return pages;
54	end = ((end - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;	58	}
55		59
56	error = -EAGAIN;	60	/*
57	tmp = (unsigned char *) __get_free_page(GFP_KERNEL);	61	* find_vma() found something, but we might be
58	if (!tmp)	62	* below it: check for that.
59	return error;	63	*/
		64	if (addr < vma->vm_start) {
		65	unsigned long gap = (vma->vm_start - addr) >> PAGE_SHIFT;
		66	if (gap > pages)
		67	gap = pages;
		68	memset(vec, 0, gap);
		69	return gap;
		70	}
60		71
61	/* (end - start) is # of pages, and also # of bytes in "vec */	72	/*
62	remaining = (end - start),	73	* Ok, got it. But check whether it's a segment we support
		74	* mincore() on. Right now, we don't do any anonymous mappings.
		75	*/
		76	if (!vma->vm_file)
		77	return -ENOMEM;
63		78
64	error = 0;	79	/*
65	for (i = 0; remaining > 0; remaining -= PAGE_SIZE, i++) {	80	* Calculate how many pages there are left in the vma, and
66	int j = 0;	81	* what the pgoff is for our address.
67	long thispiece = (remaining < PAGE_SIZE) ?	82	*/
68	remaining : PAGE_SIZE;	83	nr = (vma->vm_end - addr) >> PAGE_SHIFT;
		84	if (nr > pages)
		85	nr = pages;
69		86
70	while (j < thispiece)	87	pgoff = (addr - vma->vm_start) >> PAGE_SHIFT;
71	tmp[j++] = mincore_page(vma, start++);	88	pgoff += vma->vm_pgoff;
72		89
73	if (copy_to_user(vec + PAGE_SIZE * i, tmp, thispiece)) {	90	/* And then we just fill the sucker in.. */
74	error = -EFAULT;	91	for (i = 0 ; i < nr; i++, pgoff++)
75	break;	92	vec[i] = mincore_page(vma, pgoff);
76	}
77	}
78		93
79	free_page((unsigned long) tmp);	94	return nr;
80	return error;
81	}	95	}
82		96
83	/*	97	/*
@@ -107,82 +121,50 @@ static long mincore_vma(struct vm_area_struct * vma,
107	asmlinkage long sys_mincore(unsigned long start, size_t len,	121	asmlinkage long sys_mincore(unsigned long start, size_t len,
108	unsigned char __user * vec)	122	unsigned char __user * vec)
109	{	123	{
110	int index = 0;	124	long retval;
111	unsigned long end, limit;	125	unsigned long pages;
112	struct vm_area_struct * vma;	126	unsigned char *tmp;
113	size_t max;
114	int unmapped_error = 0;
115	long error;
116
117	/* check the arguments */
118	if (start & ~PAGE_CACHE_MASK)
119	goto einval;
120
121	limit = TASK_SIZE;
122	if (start >= limit)
123	goto enomem;
124
125	if (!len)
126	return 0;
127		127
128	max = limit - start;	128	/* Check the start address: needs to be page-aligned.. */
129	len = PAGE_CACHE_ALIGN(len);	129	if (start & ~PAGE_CACHE_MASK)
130	if (len > max \|\| !len)	130	return -EINVAL;
131	goto enomem;
132
133	end = start + len;
134		131
135	/* check the output buffer whilst holding the lock */	132	/* ..and we need to be passed a valid user-space range */
136	error = -EFAULT;	133	if (!access_ok(VERIFY_READ, (void __user *) start, len))
137	down_read(&current->mm->mmap_sem);	134	return -ENOMEM;
138		135
139	if (!access_ok(VERIFY_WRITE, vec, len >> PAGE_SHIFT))	136	/* This also avoids any overflows on PAGE_CACHE_ALIGN */
140	goto out;	137	pages = len >> PAGE_SHIFT;
		138	pages += (len & ~PAGE_MASK) != 0;
141		139
142	/*	140	if (!access_ok(VERIFY_WRITE, vec, pages))
143	* If the interval [start,end) covers some unmapped address	141	return -EFAULT;
144	* ranges, just ignore them, but return -ENOMEM at the end.
145	*/
146	error = 0;
147
148	vma = find_vma(current->mm, start);
149	while (vma) {
150	/* Here start < vma->vm_end. */
151	if (start < vma->vm_start) {
152	unmapped_error = -ENOMEM;
153	start = vma->vm_start;
154	}
155		142
156	/* Here vma->vm_start <= start < vma->vm_end. */	143	tmp = (void *) __get_free_page(GFP_USER);
157	if (end <= vma->vm_end) {	144	if (!tmp)
158	if (start < end) {	145	return -ENOMEM;
159	error = mincore_vma(vma, start, end,	146
160	&vec[index]);	147	retval = 0;
161	if (error)	148	while (pages) {
162	goto out;	149	/*
163	}	150	* Do at most PAGE_SIZE entries per iteration, due to
164	error = unmapped_error;	151	* the temporary buffer size.
165	goto out;	152	*/
		153	down_read(&current->mm->mmap_sem);
		154	retval = do_mincore(start, tmp, max(pages, PAGE_SIZE));
		155	up_read(&current->mm->mmap_sem);
		156
		157	if (retval <= 0)
		158	break;
		159	if (copy_to_user(vec, tmp, retval)) {
		160	retval = -EFAULT;
		161	break;
166	}	162	}
167		163	pages -= retval;
168	/* Here vma->vm_start <= start < vma->vm_end < end. */	164	vec += retval;
169	error = mincore_vma(vma, start, vma->vm_end, &vec[index]);	165	start += retval << PAGE_SHIFT;
170	if (error)	166	retval = 0;
171	goto out;
172	index += (vma->vm_end - start) >> PAGE_CACHE_SHIFT;
173	start = vma->vm_end;
174	vma = vma->vm_next;
175	}	167	}
176		168	free_page((unsigned long) tmp);
177	/* we found a hole in the area queried if we arrive here */	169	return retval;
178	error = -ENOMEM;
179
180	out:
181	up_read(&current->mm->mmap_sem);
182	return error;
183
184	einval:
185	return -EINVAL;
186	enomem:
187	return -ENOMEM;
188	}	170	}