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/security.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_rebolt();
 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         unsigned long min_addr = max(PAGE_SIZE, mmap_min_addr);
 381
 382         info.flags = VM_UNMAPPED_AREA_TOPDOWN;
 383         info.length = len;
 384         info.align_mask = PAGE_MASK & ((1ul << pshift) - 1);
 385         info.align_offset = 0;
 386
 387         addr = mm->mmap_base;
 388         /*
 389          * If we are trying to allocate above DEFAULT_MAP_WINDOW
 390          * Add the different to the mmap_base.
 391          * Only for that request for which high_limit is above
 392          * DEFAULT_MAP_WINDOW we should apply this.
 393          */
 394         if (high_limit > DEFAULT_MAP_WINDOW)
 395                 addr += mm->context.slb_addr_limit - DEFAULT_MAP_WINDOW;
 396
 397         while (addr > min_addr) {
 398                 info.high_limit = addr;
 399                 if (!slice_scan_available(addr - 1, available, 0, &addr))
 400                         continue;
 401
 402  prev_slice:
 403                 /*
 404                  * At this point [addr; info.high_limit) covers
 405                  * available slices only and starts at a slice boundary.
 406                  * Check if we need to reduce the range, or if we can
 407                  * extend it to cover the previous available slice.
 408                  */
 409                 if (addr < min_addr)
 410                         addr = min_addr;
 411                 else if (slice_scan_available(addr - 1, available, 0, &prev)) {
 412                         addr = prev;
 413                         goto prev_slice;
 414                 }
 415                 info.low_limit = addr;
 416
 417                 found = vm_unmapped_area(&info);
 418                 if (!(found & ~PAGE_MASK))
 419                         return found;
 420         }
 421
 422         /*
 423          * A failed mmap() very likely causes application failure,
 424          * so fall back to the bottom-up function here. This scenario
 425          * can happen with large stack limits and large mmap()
 426          * allocations.
 427          */
 428         return slice_find_area_bottomup(mm, len, available, psize, high_limit);
 429 }
 430
 431
 432 static unsigned long slice_find_area(struct mm_struct *mm, unsigned long len,
 433                                      const struct slice_mask *mask, int psize,
 434                                      int topdown, unsigned long high_limit)
 435 {
 436         if (topdown)
 437                 return slice_find_area_topdown(mm, len, mask, psize, high_limit);
 438         else
 439                 return slice_find_area_bottomup(mm, len, mask, psize, high_limit);
 440 }
 441
 442 static inline void slice_copy_mask(struct slice_mask *dst,
 443                                         const struct slice_mask *src)
 444 {
 445         dst->low_slices = src->low_slices;
 446         if (!SLICE_NUM_HIGH)
 447                 return;
 448         bitmap_copy(dst->high_slices, src->high_slices, SLICE_NUM_HIGH);
 449 }
 450
 451 static inline void slice_or_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_or(dst->high_slices, src1->high_slices, src2->high_slices, SLICE_NUM_HIGH);
 459 }
 460
 461 static inline void slice_andnot_mask(struct slice_mask *dst,
 462                                         const struct slice_mask *src1,
 463                                         const struct slice_mask *src2)
 464 {
 465         dst->low_slices = src1->low_slices & ~src2->low_slices;
 466         if (!SLICE_NUM_HIGH)
 467                 return;
 468         bitmap_andnot(dst->high_slices, src1->high_slices, src2->high_slices, SLICE_NUM_HIGH);
 469 }
 470
 471 #ifdef CONFIG_PPC_64K_PAGES
 472 #define MMU_PAGE_BASE   MMU_PAGE_64K
 473 #else
 474 #define MMU_PAGE_BASE   MMU_PAGE_4K
 475 #endif
 476
 477 unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len,
 478                                       unsigned long flags, unsigned int psize,
 479                                       int topdown)
 480 {
 481         struct slice_mask good_mask;
 482         struct slice_mask potential_mask;
 483         const struct slice_mask *maskp;
 484         const struct slice_mask *compat_maskp = NULL;
 485         int fixed = (flags & MAP_FIXED);
 486         int pshift = max_t(int, mmu_psize_defs[psize].shift, PAGE_SHIFT);
 487         unsigned long page_size = 1UL << pshift;
 488         struct mm_struct *mm = current->mm;
 489         unsigned long newaddr;
 490         unsigned long high_limit;
 491
 492         high_limit = DEFAULT_MAP_WINDOW;
 493         if (addr >= high_limit || (fixed && (addr + len > high_limit)))
 494                 high_limit = TASK_SIZE;
 495
 496         if (len > high_limit)
 497                 return -ENOMEM;
 498         if (len & (page_size - 1))
 499                 return -EINVAL;
 500         if (fixed) {
 501                 if (addr & (page_size - 1))
 502                         return -EINVAL;
 503                 if (addr > high_limit - len)
 504                         return -ENOMEM;
 505         }
 506
 507         if (high_limit > mm->context.slb_addr_limit) {
 508                 /*
 509                  * Increasing the slb_addr_limit does not require
 510                  * slice mask cache to be recalculated because it should
 511                  * be already initialised beyond the old address limit.
 512                  */
 513                 mm->context.slb_addr_limit = high_limit;
 514
 515                 on_each_cpu(slice_flush_segments, mm, 1);
 516         }
 517
 518         /* Sanity checks */
 519         BUG_ON(mm->task_size == 0);
 520         BUG_ON(mm->context.slb_addr_limit == 0);
 521         VM_BUG_ON(radix_enabled());
 522
 523         slice_dbg("slice_get_unmapped_area(mm=%p, psize=%d...\n", mm, psize);
 524         slice_dbg(" addr=%lx, len=%lx, flags=%lx, topdown=%d\n",
 525                   addr, len, flags, topdown);
 526
 527         /* If hint, make sure it matches our alignment restrictions */
 528         if (!fixed && addr) {
 529                 addr = _ALIGN_UP(addr, page_size);
 530                 slice_dbg(" aligned addr=%lx\n", addr);
 531                 /* Ignore hint if it's too large or overlaps a VMA */
 532                 if (addr > high_limit - len || addr < mmap_min_addr ||
 533                     !slice_area_is_free(mm, addr, len))
 534                         addr = 0;
 535         }
 536
 537         /* First make up a "good" mask of slices that have the right size
 538          * already
 539          */
 540         maskp = slice_mask_for_size(mm, psize);
 541
 542         /*
 543          * Here "good" means slices that are already the right page size,
 544          * "compat" means slices that have a compatible page size (i.e.
 545          * 4k in a 64k pagesize kernel), and "free" means slices without
 546          * any VMAs.
 547          *
 548          * If MAP_FIXED:
 549          *      check if fits in good | compat => OK
 550          *      check if fits in good | compat | free => convert free
 551          *      else bad
 552          * If have hint:
 553          *      check if hint fits in good => OK
 554          *      check if hint fits in good | free => convert free
 555          * Otherwise:
 556          *      search in good, found => OK
 557          *      search in good | free, found => convert free
 558          *      search in good | compat | free, found => convert free.
 559          */
 560
 561         /*
 562          * If we support combo pages, we can allow 64k pages in 4k slices
 563          * The mask copies could be avoided in most cases here if we had
 564          * a pointer to good mask for the next code to use.
 565          */
 566         if (IS_ENABLED(CONFIG_PPC_64K_PAGES) && psize == MMU_PAGE_64K) {
 567                 compat_maskp = slice_mask_for_size(mm, MMU_PAGE_4K);
 568                 if (fixed)
 569                         slice_or_mask(&good_mask, maskp, compat_maskp);
 570                 else
 571                         slice_copy_mask(&good_mask, maskp);
 572         } else {
 573                 slice_copy_mask(&good_mask, maskp);
 574         }
 575
 576         slice_print_mask(" good_mask", &good_mask);
 577         if (compat_maskp)
 578                 slice_print_mask(" compat_mask", compat_maskp);
 579
 580         /* First check hint if it's valid or if we have MAP_FIXED */
 581         if (addr != 0 || fixed) {
 582                 /* Check if we fit in the good mask. If we do, we just return,
 583                  * nothing else to do
 584                  */
 585                 if (slice_check_range_fits(mm, &good_mask, addr, len)) {
 586                         slice_dbg(" fits good !\n");
 587                         newaddr = addr;
 588                         goto return_addr;
 589                 }
 590         } else {
 591                 /* Now let's see if we can find something in the existing
 592                  * slices for that size
 593                  */
 594                 newaddr = slice_find_area(mm, len, &good_mask,
 595                                           psize, topdown, high_limit);
 596                 if (newaddr != -ENOMEM) {
 597                         /* Found within the good mask, we don't have to setup,
 598                          * we thus return directly
 599                          */
 600                         slice_dbg(" found area at 0x%lx\n", newaddr);
 601                         goto return_addr;
 602                 }
 603         }
 604         /*
 605          * We don't fit in the good mask, check what other slices are
 606          * empty and thus can be converted
 607          */
 608         slice_mask_for_free(mm, &potential_mask, high_limit);
 609         slice_or_mask(&potential_mask, &potential_mask, &good_mask);
 610         slice_print_mask(" potential", &potential_mask);
 611
 612         if (addr != 0 || fixed) {
 613                 if (slice_check_range_fits(mm, &potential_mask, addr, len)) {
 614                         slice_dbg(" fits potential !\n");
 615                         newaddr = addr;
 616                         goto convert;
 617                 }
 618         }
 619
 620         /* If we have MAP_FIXED and failed the above steps, then error out */
 621         if (fixed)
 622                 return -EBUSY;
 623
 624         slice_dbg(" search...\n");
 625
 626         /* If we had a hint that didn't work out, see if we can fit
 627          * anywhere in the good area.
 628          */
 629         if (addr) {
 630                 newaddr = slice_find_area(mm, len, &good_mask,
 631                                           psize, topdown, high_limit);
 632                 if (newaddr != -ENOMEM) {
 633                         slice_dbg(" found area at 0x%lx\n", newaddr);
 634                         goto return_addr;
 635                 }
 636         }
 637
 638         /* Now let's see if we can find something in the existing slices
 639          * for that size plus free slices
 640          */
 641         newaddr = slice_find_area(mm, len, &potential_mask,
 642                                   psize, topdown, high_limit);
 643
 644 #ifdef CONFIG_PPC_64K_PAGES
 645         if (newaddr == -ENOMEM && psize == MMU_PAGE_64K) {
 646                 /* retry the search with 4k-page slices included */
 647                 slice_or_mask(&potential_mask, &potential_mask, compat_maskp);
 648                 newaddr = slice_find_area(mm, len, &potential_mask,
 649                                           psize, topdown, high_limit);
 650         }
 651 #endif
 652
 653         if (newaddr == -ENOMEM)
 654                 return -ENOMEM;
 655
 656         slice_range_to_mask(newaddr, len, &potential_mask);
 657         slice_dbg(" found potential area at 0x%lx\n", newaddr);
 658         slice_print_mask(" mask", &potential_mask);
 659
 660  convert:
 661         /*
 662          * Try to allocate the context before we do slice convert
 663          * so that we handle the context allocation failure gracefully.
 664          */
 665         if (need_extra_context(mm, newaddr)) {
 666                 if (alloc_extended_context(mm, newaddr) < 0)
 667                         return -ENOMEM;
 668         }
 669
 670         slice_andnot_mask(&potential_mask, &potential_mask, &good_mask);
 671         if (compat_maskp && !fixed)
 672                 slice_andnot_mask(&potential_mask, &potential_mask, compat_maskp);
 673         if (potential_mask.low_slices ||
 674                 (SLICE_NUM_HIGH &&
 675                  !bitmap_empty(potential_mask.high_slices, SLICE_NUM_HIGH))) {
 676                 slice_convert(mm, &potential_mask, psize);
 677                 if (psize > MMU_PAGE_BASE)
 678                         on_each_cpu(slice_flush_segments, mm, 1);
 679         }
 680         return newaddr;
 681
 682 return_addr:
 683         if (need_extra_context(mm, newaddr)) {
 684                 if (alloc_extended_context(mm, newaddr) < 0)
 685                         return -ENOMEM;
 686         }
 687         return newaddr;
 688 }
 689 EXPORT_SYMBOL_GPL(slice_get_unmapped_area);
 690
 691 unsigned long arch_get_unmapped_area(struct file *filp,
 692                                      unsigned long addr,
 693                                      unsigned long len,
 694                                      unsigned long pgoff,
 695                                      unsigned long flags)
 696 {
 697         return slice_get_unmapped_area(addr, len, flags,
 698                                        current->mm->context.user_psize, 0);
 699 }
 700
 701 unsigned long arch_get_unmapped_area_topdown(struct file *filp,
 702                                              const unsigned long addr0,
 703                                              const unsigned long len,
 704                                              const unsigned long pgoff,
 705                                              const unsigned long flags)
 706 {
 707         return slice_get_unmapped_area(addr0, len, flags,
 708                                        current->mm->context.user_psize, 1);
 709 }
 710
 711 unsigned int get_slice_psize(struct mm_struct *mm, unsigned long addr)
 712 {
 713         unsigned char *psizes;
 714         int index, mask_index;
 715
 716         VM_BUG_ON(radix_enabled());
 717
 718         if (slice_addr_is_low(addr)) {
 719                 psizes = mm->context.low_slices_psize;
 720                 index = GET_LOW_SLICE_INDEX(addr);
 721         } else {
 722                 psizes = mm->context.high_slices_psize;
 723                 index = GET_HIGH_SLICE_INDEX(addr);
 724         }
 725         mask_index = index & 0x1;
 726         return (psizes[index >> 1] >> (mask_index * 4)) & 0xf;
 727 }
 728 EXPORT_SYMBOL_GPL(get_slice_psize);
 729
 730 void slice_init_new_context_exec(struct mm_struct *mm)
 731 {
 732         unsigned char *hpsizes, *lpsizes;
 733         struct slice_mask *mask;
 734         unsigned int psize = mmu_virtual_psize;
 735
 736         slice_dbg("slice_init_new_context_exec(mm=%p)\n", mm);
 737
 738         /*
 739          * In the case of exec, use the default limit. In the
 740          * case of fork it is just inherited from the mm being
 741          * duplicated.
 742          */
 743 #ifdef CONFIG_PPC64
 744         mm->context.slb_addr_limit = DEFAULT_MAP_WINDOW_USER64;
 745 #else
 746         mm->context.slb_addr_limit = DEFAULT_MAP_WINDOW;
 747 #endif
 748
 749         mm->context.user_psize = psize;
 750
 751         /*
 752          * Set all slice psizes to the default.
 753          */
 754         lpsizes = mm->context.low_slices_psize;
 755         memset(lpsizes, (psize << 4) | psize, SLICE_NUM_LOW >> 1);
 756
 757         hpsizes = mm->context.high_slices_psize;
 758         memset(hpsizes, (psize << 4) | psize, SLICE_NUM_HIGH >> 1);
 759
 760         /*
 761          * Slice mask cache starts zeroed, fill the default size cache.
 762          */
 763         mask = slice_mask_for_size(mm, psize);
 764         mask->low_slices = ~0UL;
 765         if (SLICE_NUM_HIGH)
 766                 bitmap_fill(mask->high_slices, SLICE_NUM_HIGH);
 767 }
 768
 769 void slice_set_range_psize(struct mm_struct *mm, unsigned long start,
 770                            unsigned long len, unsigned int psize)
 771 {
 772         struct slice_mask mask;
 773
 774         VM_BUG_ON(radix_enabled());
 775
 776         slice_range_to_mask(start, len, &mask);
 777         slice_convert(mm, &mask, psize);
 778 }
 779
 780 #ifdef CONFIG_HUGETLB_PAGE
 781 /*
 782  * is_hugepage_only_range() is used by generic code to verify whether
 783  * a normal mmap mapping (non hugetlbfs) is valid on a given area.
 784  *
 785  * until the generic code provides a more generic hook and/or starts
 786  * calling arch get_unmapped_area for MAP_FIXED (which our implementation
 787  * here knows how to deal with), we hijack it to keep standard mappings
 788  * away from us.
 789  *
 790  * because of that generic code limitation, MAP_FIXED mapping cannot
 791  * "convert" back a slice with no VMAs to the standard page size, only
 792  * get_unmapped_area() can. It would be possible to fix it here but I
 793  * prefer working on fixing the generic code instead.
 794  *
 795  * WARNING: This will not work if hugetlbfs isn't enabled since the
 796  * generic code will redefine that function as 0 in that. This is ok
 797  * for now as we only use slices with hugetlbfs enabled. This should
 798  * be fixed as the generic code gets fixed.
 799  */
 800 int slice_is_hugepage_only_range(struct mm_struct *mm, unsigned long addr,
 801                            unsigned long len)
 802 {
 803         const struct slice_mask *maskp;
 804         unsigned int psize = mm->context.user_psize;
 805
 806         VM_BUG_ON(radix_enabled());
 807
 808         maskp = slice_mask_for_size(mm, psize);
 809 #ifdef CONFIG_PPC_64K_PAGES
 810         /* We need to account for 4k slices too */
 811         if (psize == MMU_PAGE_64K) {
 812                 const struct slice_mask *compat_maskp;
 813                 struct slice_mask available;
 814
 815                 compat_maskp = slice_mask_for_size(mm, MMU_PAGE_4K);
 816                 slice_or_mask(&available, maskp, compat_maskp);
 817                 return !slice_check_range_fits(mm, &available, addr, len);
 818         }
 819 #endif
 820
 821         return !slice_check_range_fits(mm, maskp, addr, len);
 822 }
 823 #endif