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