arch/powerpc/mm/slice.c

   1 /*
   2  * address space "slices" (meta-segments) support
   3  *
   4  * Copyright (C) 2007 Benjamin Herrenschmidt, IBM Corporation.
   5  *
   6  * Based on hugetlb implementation
   7  *
   8  * Copyright (C) 2003 David Gibson, IBM Corporation.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #undef DEBUG
  26
  27 #include <linux/kernel.h>
  28 #include <linux/mm.h>
  29 #include <linux/pagemap.h>
  30 #include <linux/err.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/export.h>
  33 #include <linux/hugetlb.h>
  34 #include <linux/sched/mm.h>
  35 #include <linux/security.h>
  36 #include <asm/mman.h>
  37 #include <asm/mmu.h>
  38 #include <asm/copro.h>
  39 #include <asm/hugetlb.h>
  40 #include <asm/mmu_context.h>
  41
  42 static DEFINE_SPINLOCK(slice_convert_lock);
  43
  44 #ifdef DEBUG
  45 int _slice_debug = 1;
  46
  47 static void slice_print_mask(const char *label, const struct slice_mask *mask)
  48 {
  49         if (!_slice_debug)
  50                 return;
  51         pr_devel("%s low_slice: %*pbl\n", label,
  52                         (int)SLICE_NUM_LOW, &mask->low_slices);
  53         pr_devel("%s high_slice: %*pbl\n", label,
  54                         (int)SLICE_NUM_HIGH, mask->high_slices);
  55 }
  56
  57 #define slice_dbg(fmt...) do { if (_slice_debug) pr_devel(fmt); } while (0)
  58
  59 #else
  60
  61 static void slice_print_mask(const char *label, const struct slice_mask *mask) {}
  62 #define slice_dbg(fmt...)
  63
  64 #endif
  65
  66 static inline bool slice_addr_is_low(unsigned long addr)
  67 {
  68         u64 tmp = (u64)addr;
  69
  70         return tmp < SLICE_LOW_TOP;
  71 }
  72
  73 static void slice_range_to_mask(unsigned long start, unsigned long len,
  74                                 struct slice_mask *ret)
  75 {
  76         unsigned long end = start + len - 1;
  77
  78         ret->low_slices = 0;
  79         if (SLICE_NUM_HIGH)
  80                 bitmap_zero(ret->high_slices, SLICE_NUM_HIGH);
  81
  82         if (slice_addr_is_low(start)) {
  83                 unsigned long mend = min(end,
  84                                          (unsigned long)(SLICE_LOW_TOP - 1));
  85
  86                 ret->low_slices = (1u << (GET_LOW_SLICE_INDEX(mend) + 1))
  87                         - (1u << GET_LOW_SLICE_INDEX(start));
  88         }
  89
  90         if (SLICE_NUM_HIGH && !slice_addr_is_low(end)) {
  91                 unsigned long start_index = GET_HIGH_SLICE_INDEX(start);
  92                 unsigned long align_end = ALIGN(end, (1UL << SLICE_HIGH_SHIFT));
  93                 unsigned long count = GET_HIGH_SLICE_INDEX(align_end) - start_index;
  94
  95                 bitmap_set(ret->high_slices, start_index, count);
  96         }
  97 }
  98
  99 static int slice_area_is_free(struct mm_struct *mm, unsigned long addr,
 100                               unsigned long len)
 101 {
 102         struct vm_area_struct *vma;
 103
 104         if ((mm->context.slb_addr_limit - len) < addr)
 105                 return 0;
 106         vma = find_vma(mm, addr);
 107         return (!vma || (addr + len) <= vm_start_gap(vma));
 108 }
 109
 110 static int slice_low_has_vma(struct mm_struct *mm, unsigned long slice)
 111 {
 112         return !slice_area_is_free(mm, slice << SLICE_LOW_SHIFT,
 113                                    1ul << SLICE_LOW_SHIFT);
 114 }
 115
 116 static int slice_high_has_vma(struct mm_struct *mm, unsigned long slice)
 117 {
 118         unsigned long start = slice << SLICE_HIGH_SHIFT;
 119         unsigned long end = start + (1ul << SLICE_HIGH_SHIFT);
 120
 121 #ifdef CONFIG_PPC64
 122         /* Hack, so that each addresses is controlled by exactly one
 123          * of the high or low area bitmaps, the first high area starts
 124          * at 4GB, not 0 */
 125         if (start == 0)
 126                 start = SLICE_LOW_TOP;
 127 #endif
 128
 129         return !slice_area_is_free(mm, start, end - start);
 130 }
 131
 132 static void slice_mask_for_free(struct mm_struct *mm, struct slice_mask *ret,
 133                                 unsigned long high_limit)
 134 {
 135         unsigned long i;
 136
 137         ret->low_slices = 0;
 138         if (SLICE_NUM_HIGH)
 139                 bitmap_zero(ret->high_slices, SLICE_NUM_HIGH);
 140
 141         for (i = 0; i < SLICE_NUM_LOW; i++)
 142                 if (!slice_low_has_vma(mm, i))
 143                         ret->low_slices |= 1u << i;
 144
 145         if (slice_addr_is_low(high_limit - 1))
 146                 return;
 147
 148         for (i = 0; i < GET_HIGH_SLICE_INDEX(high_limit); i++)
 149                 if (!slice_high_has_vma(mm, i))
 150                         __set_bit(i, ret->high_slices);
 151 }
 152
 153 #ifdef CONFIG_PPC_BOOK3S_64
 154 static struct slice_mask *slice_mask_for_size(struct mm_struct *mm, int psize)
 155 {
 156 #ifdef CONFIG_PPC_64K_PAGES
 157         if (psize == MMU_PAGE_64K)
 158                 return &mm->context.mask_64k;
 159 #endif
 160         if (psize == MMU_PAGE_4K)
 161                 return &mm->context.mask_4k;
 162 #ifdef CONFIG_HUGETLB_PAGE
 163         if (psize == MMU_PAGE_16M)
 164                 return &mm->context.mask_16m;
 165         if (psize == MMU_PAGE_16G)
 166                 return &mm->context.mask_16g;
 167 #endif
 168         BUG();
 169 }
 170 #elif defined(CONFIG_PPC_8xx)
 171 static struct slice_mask *slice_mask_for_size(struct mm_struct *mm, int psize)
 172 {
 173         if (psize == mmu_virtual_psize)
 174                 return &mm->context.mask_base_psize;
 175 #ifdef CONFIG_HUGETLB_PAGE
 176         if (psize == MMU_PAGE_512K)
 177                 return &mm->context.mask_512k;
 178         if (psize == MMU_PAGE_8M)
 179                 return &mm->context.mask_8m;
 180 #endif
 181         BUG();
 182 }
 183 #else
 184 #error "Must define the slice masks for page sizes supported by the platform"
 185 #endif
 186
 187 static bool slice_check_range_fits(struct mm_struct *mm,
 188                            const struct slice_mask *available,
 189                            unsigned long start, unsigned long len)
 190 {
 191         unsigned long end = start + len - 1;
 192         u64 low_slices = 0;
 193
 194         if (slice_addr_is_low(start)) {
 195                 unsigned long mend = min(end,
 196                                          (unsigned long)(SLICE_LOW_TOP - 1));
 197
 198                 low_slices = (1u << (GET_LOW_SLICE_INDEX(mend) + 1))
 199                                 - (1u << GET_LOW_SLICE_INDEX(start));
 200         }
 201         if ((low_slices & available->low_slices) != low_slices)
 202                 return false;
 203
 204         if (SLICE_NUM_HIGH && !slice_addr_is_low(end)) {
 205                 unsigned long start_index = GET_HIGH_SLICE_INDEX(start);
 206                 unsigned long align_end = ALIGN(end, (1UL << SLICE_HIGH_SHIFT));
 207                 unsigned long count = GET_HIGH_SLICE_INDEX(align_end) - start_index;
 208                 unsigned long i;
 209
 210                 for (i = start_index; i < start_index + count; i++) {
 211                         if (!test_bit(i, available->high_slices))
 212                                 return false;
 213                 }
 214         }
 215
 216         return true;
 217 }
 218
 219 static void slice_flush_segments(void *parm)
 220 {
 221 #ifdef CONFIG_PPC64
 222         struct mm_struct *mm = parm;
 223         unsigned long flags;
 224
 225         if (mm != current->active_mm)
 226                 return;
 227
 228         copy_mm_to_paca(current->active_mm);
 229
 230         local_irq_save(flags);
 231         slb_flush_and_restore_bolted();
 232         local_irq_restore(flags);
 233 #endif
 234 }
 235
 236 static void slice_convert(struct mm_struct *mm,
 237                                 const struct slice_mask *mask, int psize)
 238 {
 239         int index, mask_index;
 240         /* Write the new slice psize bits */
 241         unsigned char *hpsizes, *lpsizes;
 242         struct slice_mask *psize_mask, *old_mask;
 243         unsigned long i, flags;
 244         int old_psize;
 245
 246         slice_dbg("slice_convert(mm=%p, psize=%d)\n", mm, psize);
 247         slice_print_mask(" mask", mask);
 248
 249         psize_mask = slice_mask_for_size(mm, psize);
 250
 251         /* We need to use a spinlock here to protect against
 252          * concurrent 64k -> 4k demotion ...
 253          */
 254         spin_lock_irqsave(&slice_convert_lock, flags);
 255
 256         lpsizes = mm->context.low_slices_psize;
 257         for (i = 0; i < SLICE_NUM_LOW; i++) {
 258                 if (!(mask->low_slices & (1u << i)))
 259                         continue;
 260
 261                 mask_index = i & 0x1;
 262                 index = i >> 1;
 263
 264                 /* Update the slice_mask */
 265                 old_psize = (lpsizes[index] >> (mask_index * 4)) & 0xf;
 266                 old_mask = slice_mask_for_size(mm, old_psize);
 267                 old_mask->low_slices &= ~(1u << i);
 268                 psize_mask->low_slices |= 1u << i;
 269
 270                 /* Update the sizes array */
 271                 lpsizes[index] = (lpsizes[index] & ~(0xf << (mask_index * 4))) |
 272                                 (((unsigned long)psize) << (mask_index * 4));
 273         }
 274
 275         hpsizes = mm->context.high_slices_psize;
 276         for (i = 0; i < GET_HIGH_SLICE_INDEX(mm->context.slb_addr_limit); i++) {
 277                 if (!test_bit(i, mask->high_slices))
 278                         continue;
 279
 280                 mask_index = i & 0x1;
 281                 index = i >> 1;
 282
 283                 /* Update the slice_mask */
 284                 old_psize = (hpsizes[index] >> (mask_index * 4)) & 0xf;
 285                 old_mask = slice_mask_for_size(mm, old_psize);
 286                 __clear_bit(i, old_mask->high_slices);
 287                 __set_bit(i, psize_mask->high_slices);
 288
 289                 /* Update the sizes array */
 290                 hpsizes[index] = (hpsizes[index] & ~(0xf << (mask_index * 4))) |
 291                                 (((unsigned long)psize) << (mask_index * 4));
 292         }
 293
 294         slice_dbg(" lsps=%lx, hsps=%lx\n",
 295                   (unsigned long)mm->context.low_slices_psize,
 296                   (unsigned long)mm->context.high_slices_psize);
 297
 298         spin_unlock_irqrestore(&slice_convert_lock, flags);
 299
 300         copro_flush_all_slbs(mm);
 301 }
 302
 303 /*
 304  * Compute which slice addr is part of;
 305  * set *boundary_addr to the start or end boundary of that slice
 306  * (depending on 'end' parameter);
 307  * return boolean indicating if the slice is marked as available in the
 308  * 'available' slice_mark.
 309  */
 310 static bool slice_scan_available(unsigned long addr,
 311                                  const struct slice_mask *available,
 312                                  int end, unsigned long *boundary_addr)
 313 {
 314         unsigned long slice;
 315         if (slice_addr_is_low(addr)) {
 316                 slice = GET_LOW_SLICE_INDEX(addr);
 317                 *boundary_addr = (slice + end) << SLICE_LOW_SHIFT;
 318                 return !!(available->low_slices & (1u << slice));
 319         } else {
 320                 slice = GET_HIGH_SLICE_INDEX(addr);
 321                 *boundary_addr = (slice + end) ?
 322                         ((slice + end) << SLICE_HIGH_SHIFT) : SLICE_LOW_TOP;
 323                 return !!test_bit(slice, available->high_slices);
 324         }
 325 }
 326
 327 static unsigned long slice_find_area_bottomup(struct mm_struct *mm,
 328                                               unsigned long len,
 329                                               const struct slice_mask *available,
 330                                               int psize, unsigned long high_limit)
 331 {
 332         int pshift = max_t(int, mmu_psize_defs[psize].shift, PAGE_SHIFT);
 333         unsigned long addr, found, next_end;
 334         struct vm_unmapped_area_info info;
 335
 336         info.flags = 0;
 337         info.length = len;
 338         info.align_mask = PAGE_MASK & ((1ul << pshift) - 1);
 339         info.align_offset = 0;
 340
 341         addr = TASK_UNMAPPED_BASE;
 342         /*
 343          * Check till the allow max value for this mmap request
 344          */
 345         while (addr < high_limit) {
 346                 info.low_limit = addr;
 347                 if (!slice_scan_available(addr, available, 1, &addr))
 348                         continue;
 349
 350  next_slice:
 351                 /*
 352                  * At this point [info.low_limit; addr) covers
 353                  * available slices only and ends at a slice boundary.
 354                  * Check if we need to reduce the range, or if we can
 355                  * extend it to cover the next available slice.
 356                  */
 357                 if (addr >= high_limit)
 358                         addr = high_limit;
 359                 else if (slice_scan_available(addr, available, 1, &next_end)) {
 360                         addr = next_end;
 361                         goto next_slice;
 362                 }
 363                 info.high_limit = addr;
 364
 365                 found = vm_unmapped_area(&info);
 366                 if (!(found & ~PAGE_MASK))
 367                         return found;
 368         }
 369
 370         return -ENOMEM;
 371 }
 372
 373 static unsigned long slice_find_area_topdown(struct mm_struct *mm,
 374                                              unsigned long len,
 375                                              const struct slice_mask *available,
 376                                              int psize, unsigned long high_limit)
 377 {
 378         int pshift = max_t(int, mmu_psize_defs[psize].shift, PAGE_SHIFT);
 379         unsigned long addr, found, prev;
 380         struct vm_unmapped_area_info info;
 381         unsigned long min_addr = max(PAGE_SIZE, mmap_min_addr);
 382
 383         info.flags = VM_UNMAPPED_AREA_TOPDOWN;
 384         info.length = len;
 385         info.align_mask = PAGE_MASK & ((1ul << pshift) - 1);
 386         info.align_offset = 0;
 387
 388         addr = mm->mmap_base;
 389         /*
 390          * If we are trying to allocate above DEFAULT_MAP_WINDOW
 391          * Add the different to the mmap_base.
 392          * Only for that request for which high_limit is above
 393          * DEFAULT_MAP_WINDOW we should apply this.
 394          */
 395         if (high_limit > DEFAULT_MAP_WINDOW)
 396                 addr += mm->context.slb_addr_limit - DEFAULT_MAP_WINDOW;
 397
 398         while (addr > min_addr) {
 399                 info.high_limit = addr;
 400                 if (!slice_scan_available(addr - 1, available, 0, &addr))
 401                         continue;
 402
 403  prev_slice:
 404                 /*
 405                  * At this point [addr; info.high_limit) covers
 406                  * available slices only and starts at a slice boundary.
 407                  * Check if we need to reduce the range, or if we can
 408                  * extend it to cover the previous available slice.
 409                  */
 410                 if (addr < min_addr)
 411                         addr = min_addr;
 412                 else if (slice_scan_available(addr - 1, available, 0, &prev)) {
 413                         addr = prev;
 414                         goto prev_slice;
 415                 }
 416                 info.low_limit = addr;
 417
 418                 found = vm_unmapped_area(&info);
 419                 if (!(found & ~PAGE_MASK))
 420                         return found;
 421         }
 422
 423         /*
 424          * A failed mmap() very likely causes application failure,
 425          * so fall back to the bottom-up function here. This scenario
 426          * can happen with large stack limits and large mmap()
 427          * allocations.
 428          */
 429         return slice_find_area_bottomup(mm, len, available, psize, high_limit);
 430 }
 431
 432
 433 static unsigned long slice_find_area(struct mm_struct *mm, unsigned long len,
 434                                      const struct slice_mask *mask, int psize,
 435                                      int topdown, unsigned long high_limit)
 436 {
 437         if (topdown)
 438                 return slice_find_area_topdown(mm, len, mask, psize, high_limit);
 439         else
 440                 return slice_find_area_bottomup(mm, len, mask, psize, high_limit);
 441 }
 442
 443 static inline void slice_copy_mask(struct slice_mask *dst,
 444                                         const struct slice_mask *src)
 445 {
 446         dst->low_slices = src->low_slices;
 447         if (!SLICE_NUM_HIGH)
 448                 return;
 449         bitmap_copy(dst->high_slices, src->high_slices, SLICE_NUM_HIGH);
 450 }
 451
 452 static inline void slice_or_mask(struct slice_mask *dst,
 453                                         const struct slice_mask *src1,
 454                                         const struct slice_mask *src2)
 455 {
 456         dst->low_slices = src1->low_slices | src2->low_slices;
 457         if (!SLICE_NUM_HIGH)
 458                 return;
 459         bitmap_or(dst->high_slices, src1->high_slices, src2->high_slices, SLICE_NUM_HIGH);
 460 }
 461
 462 static inline void slice_andnot_mask(struct slice_mask *dst,
 463                                         const struct slice_mask *src1,
 464                                         const struct slice_mask *src2)
 465 {
 466         dst->low_slices = src1->low_slices & ~src2->low_slices;
 467         if (!SLICE_NUM_HIGH)
 468                 return;
 469         bitmap_andnot(dst->high_slices, src1->high_slices, src2->high_slices, SLICE_NUM_HIGH);
 470 }
 471
 472 #ifdef CONFIG_PPC_64K_PAGES
 473 #define MMU_PAGE_BASE   MMU_PAGE_64K
 474 #else
 475 #define MMU_PAGE_BASE   MMU_PAGE_4K
 476 #endif
 477
 478 unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len,
 479                                       unsigned long flags, unsigned int psize,
 480                                       int topdown)
 481 {
 482         struct slice_mask good_mask;
 483         struct slice_mask potential_mask;
 484         const struct slice_mask *maskp;
 485         const struct slice_mask *compat_maskp = NULL;
 486         int fixed = (flags & MAP_FIXED);
 487         int pshift = max_t(int, mmu_psize_defs[psize].shift, PAGE_SHIFT);
 488         unsigned long page_size = 1UL << pshift;
 489         struct mm_struct *mm = current->mm;
 490         unsigned long newaddr;
 491         unsigned long high_limit;
 492
 493         high_limit = DEFAULT_MAP_WINDOW;
 494         if (addr >= high_limit || (fixed && (addr + len > high_limit)))
 495                 high_limit = TASK_SIZE;
 496
 497         if (len > high_limit)
 498                 return -ENOMEM;
 499         if (len & (page_size - 1))
 500                 return -EINVAL;
 501         if (fixed) {
 502                 if (addr & (page_size - 1))
 503                         return -EINVAL;
 504                 if (addr > high_limit - len)
 505                         return -ENOMEM;
 506         }
 507
 508         if (high_limit > mm->context.slb_addr_limit) {
 509                 /*
 510                  * Increasing the slb_addr_limit does not require
 511                  * slice mask cache to be recalculated because it should
 512                  * be already initialised beyond the old address limit.
 513                  */
 514                 mm->context.slb_addr_limit = high_limit;
 515
 516                 on_each_cpu(slice_flush_segments, mm, 1);
 517         }
 518
 519         /* Sanity checks */
 520         BUG_ON(mm->task_size == 0);
 521         BUG_ON(mm->context.slb_addr_limit == 0);
 522         VM_BUG_ON(radix_enabled());
 523
 524         slice_dbg("slice_get_unmapped_area(mm=%p, psize=%d...\n", mm, psize);
 525         slice_dbg(" addr=%lx, len=%lx, flags=%lx, topdown=%d\n",
 526                   addr, len, flags, topdown);
 527
 528         /* If hint, make sure it matches our alignment restrictions */
 529         if (!fixed && addr) {
 530                 addr = _ALIGN_UP(addr, page_size);
 531                 slice_dbg(" aligned addr=%lx\n", addr);
 532                 /* Ignore hint if it's too large or overlaps a VMA */
 533                 if (addr > high_limit - len || addr < mmap_min_addr ||
 534                     !slice_area_is_free(mm, addr, len))
 535                         addr = 0;
 536         }
 537
 538         /* First make up a "good" mask of slices that have the right size
 539          * already
 540          */
 541         maskp = slice_mask_for_size(mm, psize);
 542
 543         /*
 544          * Here "good" means slices that are already the right page size,
 545          * "compat" means slices that have a compatible page size (i.e.
 546          * 4k in a 64k pagesize kernel), and "free" means slices without
 547          * any VMAs.
 548          *
 549          * If MAP_FIXED:
 550          *      check if fits in good | compat => OK
 551          *      check if fits in good | compat | free => convert free
 552          *      else bad
 553          * If have hint:
 554          *      check if hint fits in good => OK
 555          *      check if hint fits in good | free => convert free
 556          * Otherwise:
 557          *      search in good, found => OK
 558          *      search in good | free, found => convert free
 559          *      search in good | compat | free, found => convert free.
 560          */
 561
 562         /*
 563          * If we support combo pages, we can allow 64k pages in 4k slices
 564          * The mask copies could be avoided in most cases here if we had
 565          * a pointer to good mask for the next code to use.
 566          */
 567         if (IS_ENABLED(CONFIG_PPC_64K_PAGES) && psize == MMU_PAGE_64K) {
 568                 compat_maskp = slice_mask_for_size(mm, MMU_PAGE_4K);
 569                 if (fixed)
 570                         slice_or_mask(&good_mask, maskp, compat_maskp);
 571                 else
 572                         slice_copy_mask(&good_mask, maskp);
 573         } else {
 574                 slice_copy_mask(&good_mask, maskp);
 575         }
 576
 577         slice_print_mask(" good_mask", &good_mask);
 578         if (compat_maskp)
 579                 slice_print_mask(" compat_mask", compat_maskp);
 580
 581         /* First check hint if it's valid or if we have MAP_FIXED */
 582         if (addr != 0 || fixed) {
 583                 /* Check if we fit in the good mask. If we do, we just return,
 584                  * nothing else to do
 585                  */
 586                 if (slice_check_range_fits(mm, &good_mask, addr, len)) {
 587                         slice_dbg(" fits good !\n");
 588                         newaddr = addr;
 589                         goto return_addr;
 590                 }
 591         } else {
 592                 /* Now let's see if we can find something in the existing
 593                  * slices for that size
 594                  */
 595                 newaddr = slice_find_area(mm, len, &good_mask,
 596                                           psize, topdown, high_limit);
 597                 if (newaddr != -ENOMEM) {
 598                         /* Found within the good mask, we don't have to setup,
 599                          * we thus return directly
 600                          */
 601                         slice_dbg(" found area at 0x%lx\n", newaddr);
 602                         goto return_addr;
 603                 }
 604         }
 605         /*
 606          * We don't fit in the good mask, check what other slices are
 607          * empty and thus can be converted
 608          */
 609         slice_mask_for_free(mm, &potential_mask, high_limit);
 610         slice_or_mask(&potential_mask, &potential_mask, &good_mask);
 611         slice_print_mask(" potential", &potential_mask);
 612
 613         if (addr != 0 || fixed) {
 614                 if (slice_check_range_fits(mm, &potential_mask, addr, len)) {
 615                         slice_dbg(" fits potential !\n");
 616                         newaddr = addr;
 617                         goto convert;
 618                 }
 619         }
 620
 621         /* If we have MAP_FIXED and failed the above steps, then error out */
 622         if (fixed)
 623                 return -EBUSY;
 624
 625         slice_dbg(" search...\n");
 626
 627         /* If we had a hint that didn't work out, see if we can fit
 628          * anywhere in the good area.
 629          */
 630         if (addr) {
 631                 newaddr = slice_find_area(mm, len, &good_mask,
 632                                           psize, topdown, high_limit);
 633                 if (newaddr != -ENOMEM) {
 634                         slice_dbg(" found area at 0x%lx\n", newaddr);
 635                         goto return_addr;
 636                 }
 637         }
 638
 639         /* Now let's see if we can find something in the existing slices
 640          * for that size plus free slices
 641          */
 642         newaddr = slice_find_area(mm, len, &potential_mask,
 643                                   psize, topdown, high_limit);
 644
 645 #ifdef CONFIG_PPC_64K_PAGES
 646         if (newaddr == -ENOMEM && psize == MMU_PAGE_64K) {
 647                 /* retry the search with 4k-page slices included */
 648                 slice_or_mask(&potential_mask, &potential_mask, compat_maskp);
 649                 newaddr = slice_find_area(mm, len, &potential_mask,
 650                                           psize, topdown, high_limit);
 651         }
 652 #endif
 653
 654         if (newaddr == -ENOMEM)
 655                 return -ENOMEM;
 656
 657         slice_range_to_mask(newaddr, len, &potential_mask);
 658         slice_dbg(" found potential area at 0x%lx\n", newaddr);
 659         slice_print_mask(" mask", &potential_mask);
 660
 661  convert:
 662         /*
 663          * Try to allocate the context before we do slice convert
 664          * so that we handle the context allocation failure gracefully.
 665          */
 666         if (need_extra_context(mm, newaddr)) {
 667                 if (alloc_extended_context(mm, newaddr) < 0)
 668                         return -ENOMEM;
 669         }
 670
 671         slice_andnot_mask(&potential_mask, &potential_mask, &good_mask);
 672         if (compat_maskp && !fixed)
 673                 slice_andnot_mask(&potential_mask, &potential_mask, compat_maskp);
 674         if (potential_mask.low_slices ||
 675                 (SLICE_NUM_HIGH &&
 676                  !bitmap_empty(potential_mask.high_slices, SLICE_NUM_HIGH))) {
 677                 slice_convert(mm, &potential_mask, psize);
 678                 if (psize > MMU_PAGE_BASE)
 679                         on_each_cpu(slice_flush_segments, mm, 1);
 680         }
 681         return newaddr;
 682
 683 return_addr:
 684         if (need_extra_context(mm, newaddr)) {
 685                 if (alloc_extended_context(mm, newaddr) < 0)
 686                         return -ENOMEM;
 687         }
 688         return newaddr;
 689 }
 690 EXPORT_SYMBOL_GPL(slice_get_unmapped_area);
 691
 692 unsigned long arch_get_unmapped_area(struct file *filp,
 693                                      unsigned long addr,
 694                                      unsigned long len,
 695                                      unsigned long pgoff,
 696                                      unsigned long flags)
 697 {
 698         return slice_get_unmapped_area(addr, len, flags,
 699                                        current->mm->context.user_psize, 0);
 700 }
 701
 702 unsigned long arch_get_unmapped_area_topdown(struct file *filp,
 703                                              const unsigned long addr0,
 704                                              const unsigned long len,
 705                                              const unsigned long pgoff,
 706                                              const unsigned long flags)
 707 {
 708         return slice_get_unmapped_area(addr0, len, flags,
 709                                        current->mm->context.user_psize, 1);
 710 }
 711
 712 unsigned int get_slice_psize(struct mm_struct *mm, unsigned long addr)
 713 {
 714         unsigned char *psizes;
 715         int index, mask_index;
 716
 717         VM_BUG_ON(radix_enabled());
 718
 719         if (slice_addr_is_low(addr)) {
 720                 psizes = mm->context.low_slices_psize;
 721                 index = GET_LOW_SLICE_INDEX(addr);
 722         } else {
 723                 psizes = mm->context.high_slices_psize;
 724                 index = GET_HIGH_SLICE_INDEX(addr);
 725         }
 726         mask_index = index & 0x1;
 727         return (psizes[index >> 1] >> (mask_index * 4)) & 0xf;
 728 }
 729 EXPORT_SYMBOL_GPL(get_slice_psize);
 730
 731 void slice_init_new_context_exec(struct mm_struct *mm)
 732 {
 733         unsigned char *hpsizes, *lpsizes;
 734         struct slice_mask *mask;
 735         unsigned int psize = mmu_virtual_psize;
 736
 737         slice_dbg("slice_init_new_context_exec(mm=%p)\n", mm);
 738
 739         /*
 740          * In the case of exec, use the default limit. In the
 741          * case of fork it is just inherited from the mm being
 742          * duplicated.
 743          */
 744 #ifdef CONFIG_PPC64
 745         mm->context.slb_addr_limit = DEFAULT_MAP_WINDOW_USER64;
 746 #else
 747         mm->context.slb_addr_limit = DEFAULT_MAP_WINDOW;
 748 #endif
 749
 750         mm->context.user_psize = psize;
 751
 752         /*
 753          * Set all slice psizes to the default.
 754          */
 755         lpsizes = mm->context.low_slices_psize;
 756         memset(lpsizes, (psize << 4) | psize, SLICE_NUM_LOW >> 1);
 757
 758         hpsizes = mm->context.high_slices_psize;
 759         memset(hpsizes, (psize << 4) | psize, SLICE_NUM_HIGH >> 1);
 760
 761         /*
 762          * Slice mask cache starts zeroed, fill the default size cache.
 763          */
 764         mask = slice_mask_for_size(mm, psize);
 765         mask->low_slices = ~0UL;
 766         if (SLICE_NUM_HIGH)
 767                 bitmap_fill(mask->high_slices, SLICE_NUM_HIGH);
 768 }
 769
 770 #ifdef CONFIG_PPC_BOOK3S_64
 771 void slice_setup_new_exec(void)
 772 {
 773         struct mm_struct *mm = current->mm;
 774
 775         slice_dbg("slice_setup_new_exec(mm=%p)\n", mm);
 776
 777         if (!is_32bit_task())
 778                 return;
 779
 780         mm->context.slb_addr_limit = DEFAULT_MAP_WINDOW;
 781 }
 782 #endif
 783
 784 void slice_set_range_psize(struct mm_struct *mm, unsigned long start,
 785                            unsigned long len, unsigned int psize)
 786 {
 787         struct slice_mask mask;
 788
 789         VM_BUG_ON(radix_enabled());
 790
 791         slice_range_to_mask(start, len, &mask);
 792         slice_convert(mm, &mask, psize);
 793 }
 794
 795 #ifdef CONFIG_HUGETLB_PAGE
 796 /*
 797  * is_hugepage_only_range() is used by generic code to verify whether
 798  * a normal mmap mapping (non hugetlbfs) is valid on a given area.
 799  *
 800  * until the generic code provides a more generic hook and/or starts
 801  * calling arch get_unmapped_area for MAP_FIXED (which our implementation
 802  * here knows how to deal with), we hijack it to keep standard mappings
 803  * away from us.
 804  *
 805  * because of that generic code limitation, MAP_FIXED mapping cannot
 806  * "convert" back a slice with no VMAs to the standard page size, only
 807  * get_unmapped_area() can. It would be possible to fix it here but I
 808  * prefer working on fixing the generic code instead.
 809  *
 810  * WARNING: This will not work if hugetlbfs isn't enabled since the
 811  * generic code will redefine that function as 0 in that. This is ok
 812  * for now as we only use slices with hugetlbfs enabled. This should
 813  * be fixed as the generic code gets fixed.
 814  */
 815 int slice_is_hugepage_only_range(struct mm_struct *mm, unsigned long addr,
 816                            unsigned long len)
 817 {
 818         const struct slice_mask *maskp;
 819         unsigned int psize = mm->context.user_psize;
 820
 821         VM_BUG_ON(radix_enabled());
 822
 823         maskp = slice_mask_for_size(mm, psize);
 824 #ifdef CONFIG_PPC_64K_PAGES
 825         /* We need to account for 4k slices too */
 826         if (psize == MMU_PAGE_64K) {
 827                 const struct slice_mask *compat_maskp;
 828                 struct slice_mask available;
 829
 830                 compat_maskp = slice_mask_for_size(mm, MMU_PAGE_4K);
 831                 slice_or_mask(&available, maskp, compat_maskp);
 832                 return !slice_check_range_fits(mm, &available, addr, len);
 833         }
 834 #endif
 835
 836         return !slice_check_range_fits(mm, maskp, addr, len);
 837 }
 838 #endif