Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * flexible mmap layout support |
| 3 | * |
| 4 | * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina. |
| 5 | * All Rights Reserved. |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License as published by |
| 9 | * the Free Software Foundation; either version 2 of the License, or |
| 10 | * (at your option) any later version. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | * GNU General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program; if not, write to the Free Software |
| 19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 20 | * |
| 21 | * |
| 22 | * Started by Ingo Molnar <mingo@elte.hu> |
| 23 | */ |
| 24 | |
| 25 | #include <linux/personality.h> |
| 26 | #include <linux/mm.h> |
Martin Schwidefsky | 638ad34 | 2011-10-30 15:17:13 +0100 | [diff] [blame] | 27 | #include <linux/mman.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include <linux/module.h> |
Heiko Carstens | df1ca53 | 2011-01-12 09:55:27 +0100 | [diff] [blame] | 29 | #include <linux/random.h> |
Heiko Carstens | 048cd4e | 2012-02-27 10:01:52 +0100 | [diff] [blame] | 30 | #include <linux/compat.h> |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 31 | #include <linux/security.h> |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 32 | #include <asm/pgalloc.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
Heiko Carstens | 9046e40 | 2011-01-12 09:55:22 +0100 | [diff] [blame] | 34 | static unsigned long stack_maxrandom_size(void) |
| 35 | { |
| 36 | if (!(current->flags & PF_RANDOMIZE)) |
| 37 | return 0; |
| 38 | if (current->personality & ADDR_NO_RANDOMIZE) |
| 39 | return 0; |
| 40 | return STACK_RND_MASK << PAGE_SHIFT; |
| 41 | } |
| 42 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | /* |
| 44 | * Top of mmap area (just below the process stack). |
| 45 | * |
Heiko Carstens | 9e78a13 | 2011-01-12 09:55:23 +0100 | [diff] [blame] | 46 | * Leave at least a ~32 MB hole. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | */ |
Heiko Carstens | 9e78a13 | 2011-01-12 09:55:23 +0100 | [diff] [blame] | 48 | #define MIN_GAP (32*1024*1024) |
Martin Schwidefsky | f481bfa | 2009-03-18 13:27:36 +0100 | [diff] [blame] | 49 | #define MAX_GAP (STACK_TOP/6*5) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
Heiko Carstens | 1060f62 | 2011-01-12 09:55:26 +0100 | [diff] [blame] | 51 | static inline int mmap_is_legacy(void) |
| 52 | { |
| 53 | if (current->personality & ADDR_COMPAT_LAYOUT) |
| 54 | return 1; |
| 55 | if (rlimit(RLIMIT_STACK) == RLIM_INFINITY) |
| 56 | return 1; |
| 57 | return sysctl_legacy_va_layout; |
| 58 | } |
| 59 | |
Kees Cook | 2b68f6c | 2015-04-14 15:48:00 -0700 | [diff] [blame] | 60 | unsigned long arch_mmap_rnd(void) |
Heiko Carstens | df1ca53 | 2011-01-12 09:55:27 +0100 | [diff] [blame] | 61 | { |
Martin Schwidefsky | c7e8b2c | 2015-11-10 12:30:28 +0100 | [diff] [blame] | 62 | return (get_random_int() & MMAP_RND_MASK) << PAGE_SHIFT; |
Heiko Carstens | df1ca53 | 2011-01-12 09:55:27 +0100 | [diff] [blame] | 63 | } |
| 64 | |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 65 | static unsigned long mmap_base_legacy(unsigned long rnd) |
Heiko Carstens | 7aba842 | 2013-11-12 15:07:55 -0800 | [diff] [blame] | 66 | { |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 67 | return TASK_UNMAPPED_BASE + rnd; |
Heiko Carstens | 7aba842 | 2013-11-12 15:07:55 -0800 | [diff] [blame] | 68 | } |
| 69 | |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 70 | static inline unsigned long mmap_base(unsigned long rnd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | { |
Jiri Slaby | a58c26b | 2010-01-13 20:44:33 +0100 | [diff] [blame] | 72 | unsigned long gap = rlimit(RLIMIT_STACK); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | if (gap < MIN_GAP) |
| 75 | gap = MIN_GAP; |
| 76 | else if (gap > MAX_GAP) |
| 77 | gap = MAX_GAP; |
Heiko Carstens | df1ca53 | 2011-01-12 09:55:27 +0100 | [diff] [blame] | 78 | gap &= PAGE_MASK; |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 79 | return STACK_TOP - stack_maxrandom_size() - rnd - gap; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 82 | unsigned long |
| 83 | arch_get_unmapped_area(struct file *filp, unsigned long addr, |
| 84 | unsigned long len, unsigned long pgoff, unsigned long flags) |
| 85 | { |
| 86 | struct mm_struct *mm = current->mm; |
| 87 | struct vm_area_struct *vma; |
| 88 | struct vm_unmapped_area_info info; |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 89 | |
| 90 | if (len > TASK_SIZE - mmap_min_addr) |
| 91 | return -ENOMEM; |
| 92 | |
| 93 | if (flags & MAP_FIXED) |
| 94 | return addr; |
| 95 | |
| 96 | if (addr) { |
| 97 | addr = PAGE_ALIGN(addr); |
| 98 | vma = find_vma(mm, addr); |
| 99 | if (TASK_SIZE - len >= addr && addr >= mmap_min_addr && |
| 100 | (!vma || addr + len <= vma->vm_start)) |
| 101 | return addr; |
| 102 | } |
| 103 | |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 104 | info.flags = 0; |
| 105 | info.length = len; |
| 106 | info.low_limit = mm->mmap_base; |
| 107 | info.high_limit = TASK_SIZE; |
Martin Schwidefsky | c7e8b2c | 2015-11-10 12:30:28 +0100 | [diff] [blame] | 108 | if (filp || (flags & MAP_SHARED)) |
| 109 | info.align_mask = MMAP_ALIGN_MASK << PAGE_SHIFT; |
| 110 | else |
| 111 | info.align_mask = 0; |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 112 | info.align_offset = pgoff << PAGE_SHIFT; |
| 113 | return vm_unmapped_area(&info); |
| 114 | } |
| 115 | |
| 116 | unsigned long |
| 117 | arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, |
| 118 | const unsigned long len, const unsigned long pgoff, |
| 119 | const unsigned long flags) |
| 120 | { |
| 121 | struct vm_area_struct *vma; |
| 122 | struct mm_struct *mm = current->mm; |
| 123 | unsigned long addr = addr0; |
| 124 | struct vm_unmapped_area_info info; |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 125 | |
| 126 | /* requested length too big for entire address space */ |
| 127 | if (len > TASK_SIZE - mmap_min_addr) |
| 128 | return -ENOMEM; |
| 129 | |
| 130 | if (flags & MAP_FIXED) |
| 131 | return addr; |
| 132 | |
| 133 | /* requesting a specific address */ |
| 134 | if (addr) { |
| 135 | addr = PAGE_ALIGN(addr); |
| 136 | vma = find_vma(mm, addr); |
| 137 | if (TASK_SIZE - len >= addr && addr >= mmap_min_addr && |
| 138 | (!vma || addr + len <= vma->vm_start)) |
| 139 | return addr; |
| 140 | } |
| 141 | |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 142 | info.flags = VM_UNMAPPED_AREA_TOPDOWN; |
| 143 | info.length = len; |
| 144 | info.low_limit = max(PAGE_SIZE, mmap_min_addr); |
| 145 | info.high_limit = mm->mmap_base; |
Martin Schwidefsky | c7e8b2c | 2015-11-10 12:30:28 +0100 | [diff] [blame] | 146 | if (filp || (flags & MAP_SHARED)) |
| 147 | info.align_mask = MMAP_ALIGN_MASK << PAGE_SHIFT; |
| 148 | else |
| 149 | info.align_mask = 0; |
Martin Schwidefsky | 1f6b83e | 2015-01-14 17:51:17 +0100 | [diff] [blame] | 150 | info.align_offset = pgoff << PAGE_SHIFT; |
| 151 | addr = vm_unmapped_area(&info); |
| 152 | |
| 153 | /* |
| 154 | * A failed mmap() very likely causes application failure, |
| 155 | * so fall back to the bottom-up function here. This scenario |
| 156 | * can happen with large stack limits and large mmap() |
| 157 | * allocations. |
| 158 | */ |
| 159 | if (addr & ~PAGE_MASK) { |
| 160 | VM_BUG_ON(addr != -ENOMEM); |
| 161 | info.flags = 0; |
| 162 | info.low_limit = TASK_UNMAPPED_BASE; |
| 163 | info.high_limit = TASK_SIZE; |
| 164 | addr = vm_unmapped_area(&info); |
| 165 | } |
| 166 | |
| 167 | return addr; |
| 168 | } |
| 169 | |
Hendrik Brueckner | 486c0a0 | 2013-02-11 14:29:49 +0100 | [diff] [blame] | 170 | int s390_mmap_check(unsigned long addr, unsigned long len, unsigned long flags) |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 171 | { |
Hendrik Brueckner | 486c0a0 | 2013-02-11 14:29:49 +0100 | [diff] [blame] | 172 | if (is_compat_task() || (TASK_SIZE >= (1UL << 53))) |
| 173 | return 0; |
| 174 | if (!(flags & MAP_FIXED)) |
| 175 | addr = 0; |
Martin Schwidefsky | 1060786 | 2013-10-28 14:48:30 +0100 | [diff] [blame] | 176 | if ((addr + len) >= TASK_SIZE) |
| 177 | return crst_table_upgrade(current->mm, 1UL << 53); |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 178 | return 0; |
| 179 | } |
| 180 | |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 181 | static unsigned long |
| 182 | s390_get_unmapped_area(struct file *filp, unsigned long addr, |
| 183 | unsigned long len, unsigned long pgoff, unsigned long flags) |
| 184 | { |
| 185 | struct mm_struct *mm = current->mm; |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 186 | unsigned long area; |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 187 | int rc; |
| 188 | |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 189 | area = arch_get_unmapped_area(filp, addr, len, pgoff, flags); |
| 190 | if (!(area & ~PAGE_MASK)) |
| 191 | return area; |
Heiko Carstens | 7757591 | 2009-06-12 10:26:25 +0200 | [diff] [blame] | 192 | if (area == -ENOMEM && !is_compat_task() && TASK_SIZE < (1UL << 53)) { |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 193 | /* Upgrade the page table to 4 levels and retry. */ |
| 194 | rc = crst_table_upgrade(mm, 1UL << 53); |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 195 | if (rc) |
| 196 | return (unsigned long) rc; |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 197 | area = arch_get_unmapped_area(filp, addr, len, pgoff, flags); |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 198 | } |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 199 | return area; |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | static unsigned long |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 203 | s390_get_unmapped_area_topdown(struct file *filp, const unsigned long addr, |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 204 | const unsigned long len, const unsigned long pgoff, |
| 205 | const unsigned long flags) |
| 206 | { |
| 207 | struct mm_struct *mm = current->mm; |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 208 | unsigned long area; |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 209 | int rc; |
| 210 | |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 211 | area = arch_get_unmapped_area_topdown(filp, addr, len, pgoff, flags); |
| 212 | if (!(area & ~PAGE_MASK)) |
| 213 | return area; |
Heiko Carstens | 7757591 | 2009-06-12 10:26:25 +0200 | [diff] [blame] | 214 | if (area == -ENOMEM && !is_compat_task() && TASK_SIZE < (1UL << 53)) { |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 215 | /* Upgrade the page table to 4 levels and retry. */ |
| 216 | rc = crst_table_upgrade(mm, 1UL << 53); |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 217 | if (rc) |
| 218 | return (unsigned long) rc; |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 219 | area = arch_get_unmapped_area_topdown(filp, addr, len, |
| 220 | pgoff, flags); |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 221 | } |
Martin Schwidefsky | 0fb1d9b | 2009-03-18 13:27:37 +0100 | [diff] [blame] | 222 | return area; |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 223 | } |
| 224 | /* |
| 225 | * This function, called very early during the creation of a new |
| 226 | * process VM image, sets up which VM layout function to use: |
| 227 | */ |
| 228 | void arch_pick_mmap_layout(struct mm_struct *mm) |
| 229 | { |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 230 | unsigned long random_factor = 0UL; |
| 231 | |
| 232 | if (current->flags & PF_RANDOMIZE) |
Kees Cook | 2b68f6c | 2015-04-14 15:48:00 -0700 | [diff] [blame] | 233 | random_factor = arch_mmap_rnd(); |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 234 | |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 235 | /* |
| 236 | * Fall back to the standard layout if the personality |
| 237 | * bit is set, or if the expected stack growth is unlimited: |
| 238 | */ |
| 239 | if (mmap_is_legacy()) { |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 240 | mm->mmap_base = mmap_base_legacy(random_factor); |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 241 | mm->get_unmapped_area = s390_get_unmapped_area; |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 242 | } else { |
Kees Cook | 8e89a35 | 2015-04-14 15:47:57 -0700 | [diff] [blame] | 243 | mm->mmap_base = mmap_base(random_factor); |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 244 | mm->get_unmapped_area = s390_get_unmapped_area_topdown; |
Martin Schwidefsky | 6252d70 | 2008-02-09 18:24:37 +0100 | [diff] [blame] | 245 | } |
| 246 | } |