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