page-flags: introduce page flags policies wrt compound pages

[cascardo/linux.git] / kernel / sysctl.c

diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index dc6858d..c810f8a 100644 (file)
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -1568,6 +1568,28 @@ static struct ctl_table vm_table[] = {
                .mode           = 0644,
                .proc_handler   = proc_doulongvec_minmax,
        },
+#ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
+       {
+               .procname       = "mmap_rnd_bits",
+               .data           = &mmap_rnd_bits,
+               .maxlen         = sizeof(mmap_rnd_bits),
+               .mode           = 0600,
+               .proc_handler   = proc_dointvec_minmax,
+               .extra1         = (void *)&mmap_rnd_bits_min,
+               .extra2         = (void *)&mmap_rnd_bits_max,
+       },
+#endif
+#ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
+       {
+               .procname       = "mmap_rnd_compat_bits",
+               .data           = &mmap_rnd_compat_bits,
+               .maxlen         = sizeof(mmap_rnd_compat_bits),
+               .mode           = 0600,
+               .proc_handler   = proc_dointvec_minmax,
+               .extra1         = (void *)&mmap_rnd_compat_bits_min,
+               .extra2         = (void *)&mmap_rnd_compat_bits_max,
+       },
+#endif
        { }
 };
 
@@ -2047,9 +2069,8 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
                  void *data)
 {
        int *i, vleft, first = 1, err = 0;
-       unsigned long page = 0;
        size_t left;
-       char *kbuf;
+       char *kbuf = NULL, *p;
        
        if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
                *lenp = 0;
@@ -2078,15 +2099,9 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
 
                if (left > PAGE_SIZE - 1)
                        left = PAGE_SIZE - 1;
-               page = __get_free_page(GFP_TEMPORARY);
-               kbuf = (char *) page;
-               if (!kbuf)
-                       return -ENOMEM;
-               if (copy_from_user(kbuf, buffer, left)) {
-                       err = -EFAULT;
-                       goto free;
-               }
-               kbuf[left] = 0;
+               p = kbuf = memdup_user_nul(buffer, left);
+               if (IS_ERR(kbuf))
+                       return PTR_ERR(kbuf);
        }
 
        for (; left && vleft--; i++, first=0) {
@@ -2094,11 +2109,11 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
                bool neg;
 
                if (write) {
-                       left -= proc_skip_spaces(&kbuf);
+                       left -= proc_skip_spaces(&p);
 
                        if (!left)
                                break;
-                       err = proc_get_long(&kbuf, &left, &lval, &neg,
+                       err = proc_get_long(&p, &left, &lval, &neg,
                                             proc_wspace_sep,
                                             sizeof(proc_wspace_sep), NULL);
                        if (err)
@@ -2125,10 +2140,9 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
        if (!write && !first && left && !err)
                err = proc_put_char(&buffer, &left, '\n');
        if (write && !err && left)
-               left -= proc_skip_spaces(&kbuf);
-free:
+               left -= proc_skip_spaces(&p);
        if (write) {
-               free_page(page);
+               kfree(kbuf);
                if (first)
                        return err ? : -EINVAL;
        }
@@ -2310,9 +2324,8 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
 {
        unsigned long *i, *min, *max;
        int vleft, first = 1, err = 0;
-       unsigned long page = 0;
        size_t left;
-       char *kbuf;
+       char *kbuf = NULL, *p;
 
        if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
                *lenp = 0;
@@ -2340,15 +2353,9 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
 
                if (left > PAGE_SIZE - 1)
                        left = PAGE_SIZE - 1;
-               page = __get_free_page(GFP_TEMPORARY);
-               kbuf = (char *) page;
-               if (!kbuf)
-                       return -ENOMEM;
-               if (copy_from_user(kbuf, buffer, left)) {
-                       err = -EFAULT;
-                       goto free;
-               }
-               kbuf[left] = 0;
+               p = kbuf = memdup_user_nul(buffer, left);
+               if (IS_ERR(kbuf))
+                       return PTR_ERR(kbuf);
        }
 
        for (; left && vleft--; i++, first = 0) {
@@ -2357,9 +2364,9 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
                if (write) {
                        bool neg;
 
-                       left -= proc_skip_spaces(&kbuf);
+                       left -= proc_skip_spaces(&p);
 
-                       err = proc_get_long(&kbuf, &left, &val, &neg,
+                       err = proc_get_long(&p, &left, &val, &neg,
                                             proc_wspace_sep,
                                             sizeof(proc_wspace_sep), NULL);
                        if (err)
@@ -2385,10 +2392,9 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
        if (!write && !first && left && !err)
                err = proc_put_char(&buffer, &left, '\n');
        if (write && !err)
-               left -= proc_skip_spaces(&kbuf);
-free:
+               left -= proc_skip_spaces(&p);
        if (write) {
-               free_page(page);
+               kfree(kbuf);
                if (first)
                        return err ? : -EINVAL;
        }
@@ -2650,34 +2656,27 @@ int proc_do_large_bitmap(struct ctl_table *table, int write,
        }
 
        if (write) {
-               unsigned long page = 0;
-               char *kbuf;
+               char *kbuf, *p;
 
                if (left > PAGE_SIZE - 1)
                        left = PAGE_SIZE - 1;
 
-               page = __get_free_page(GFP_TEMPORARY);
-               kbuf = (char *) page;
-               if (!kbuf)
-                       return -ENOMEM;
-               if (copy_from_user(kbuf, buffer, left)) {
-                       free_page(page);
-                       return -EFAULT;
-                }
-               kbuf[left] = 0;
+               p = kbuf = memdup_user_nul(buffer, left);
+               if (IS_ERR(kbuf))
+                       return PTR_ERR(kbuf);
 
                tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
                                     GFP_KERNEL);
                if (!tmp_bitmap) {
-                       free_page(page);
+                       kfree(kbuf);
                        return -ENOMEM;
                }
-               proc_skip_char(&kbuf, &left, '\n');
+               proc_skip_char(&p, &left, '\n');
                while (!err && left) {
                        unsigned long val_a, val_b;
                        bool neg;
 
-                       err = proc_get_long(&kbuf, &left, &val_a, &neg, tr_a,
+                       err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
                                             sizeof(tr_a), &c);
                        if (err)
                                break;
@@ -2688,12 +2687,12 @@ int proc_do_large_bitmap(struct ctl_table *table, int write,
 
                        val_b = val_a;
                        if (left) {
-                               kbuf++;
+                               p++;
                                left--;
                        }
 
                        if (c == '-') {
-                               err = proc_get_long(&kbuf, &left, &val_b,
+                               err = proc_get_long(&p, &left, &val_b,
                                                     &neg, tr_b, sizeof(tr_b),
                                                     &c);
                                if (err)
@@ -2704,16 +2703,16 @@ int proc_do_large_bitmap(struct ctl_table *table, int write,
                                        break;
                                }
                                if (left) {
-                                       kbuf++;
+                                       p++;
                                        left--;
                                }
                        }
 
                        bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
                        first = 0;
-                       proc_skip_char(&kbuf, &left, '\n');
+                       proc_skip_char(&p, &left, '\n');
                }
-               free_page(page);
+               kfree(kbuf);
        } else {
                unsigned long bit_a, bit_b = 0;