2 * address space "slices" (meta-segments) support
4 * Copyright (C) 2007 Benjamin Herrenschmidt, IBM Corporation.
6 * Based on hugetlb implementation
8 * Copyright (C) 2003 David Gibson, IBM Corporation.
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.
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.
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
27 #include <linux/kernel.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>
36 #include <asm/copro.h>
37 #include <asm/hugetlb.h>
39 static DEFINE_SPINLOCK(slice_convert_lock
);
41 * One bit per slice. We have lower slices which cover 256MB segments
42 * upto 4G range. That gets us 16 low slices. For the rest we track slices
47 DECLARE_BITMAP(high_slices
, SLICE_NUM_HIGH
);
53 static void slice_print_mask(const char *label
, struct slice_mask mask
)
57 pr_devel("%s low_slice: %*pbl\n", label
, (int)SLICE_NUM_LOW
, &mask
.low_slices
);
58 pr_devel("%s high_slice: %*pbl\n", label
, (int)SLICE_NUM_HIGH
, mask
.high_slices
);
61 #define slice_dbg(fmt...) do { if (_slice_debug) pr_devel(fmt); } while (0)
65 static void slice_print_mask(const char *label
, struct slice_mask mask
) {}
66 #define slice_dbg(fmt...)
70 static void slice_range_to_mask(unsigned long start
, unsigned long len
,
71 struct slice_mask
*ret
)
73 unsigned long end
= start
+ len
- 1;
76 bitmap_zero(ret
->high_slices
, SLICE_NUM_HIGH
);
78 if (start
< SLICE_LOW_TOP
) {
79 unsigned long mend
= min(end
, (SLICE_LOW_TOP
- 1));
81 ret
->low_slices
= (1u << (GET_LOW_SLICE_INDEX(mend
) + 1))
82 - (1u << GET_LOW_SLICE_INDEX(start
));
85 if ((start
+ len
) > SLICE_LOW_TOP
) {
86 unsigned long start_index
= GET_HIGH_SLICE_INDEX(start
);
87 unsigned long align_end
= ALIGN(end
, (1UL << SLICE_HIGH_SHIFT
));
88 unsigned long count
= GET_HIGH_SLICE_INDEX(align_end
) - start_index
;
90 bitmap_set(ret
->high_slices
, start_index
, count
);
94 static int slice_area_is_free(struct mm_struct
*mm
, unsigned long addr
,
97 struct vm_area_struct
*vma
;
99 if ((mm
->task_size
- len
) < addr
)
101 vma
= find_vma(mm
, addr
);
102 return (!vma
|| (addr
+ len
) <= vma
->vm_start
);
105 static int slice_low_has_vma(struct mm_struct
*mm
, unsigned long slice
)
107 return !slice_area_is_free(mm
, slice
<< SLICE_LOW_SHIFT
,
108 1ul << SLICE_LOW_SHIFT
);
111 static int slice_high_has_vma(struct mm_struct
*mm
, unsigned long slice
)
113 unsigned long start
= slice
<< SLICE_HIGH_SHIFT
;
114 unsigned long end
= start
+ (1ul << SLICE_HIGH_SHIFT
);
116 /* Hack, so that each addresses is controlled by exactly one
117 * of the high or low area bitmaps, the first high area starts
120 start
= SLICE_LOW_TOP
;
122 return !slice_area_is_free(mm
, start
, end
- start
);
125 static void slice_mask_for_free(struct mm_struct
*mm
, struct slice_mask
*ret
)
130 bitmap_zero(ret
->high_slices
, SLICE_NUM_HIGH
);
132 for (i
= 0; i
< SLICE_NUM_LOW
; i
++)
133 if (!slice_low_has_vma(mm
, i
))
134 ret
->low_slices
|= 1u << i
;
136 if (mm
->task_size
<= SLICE_LOW_TOP
)
139 for (i
= 0; i
< GET_HIGH_SLICE_INDEX(mm
->context
.addr_limit
); i
++)
140 if (!slice_high_has_vma(mm
, i
))
141 __set_bit(i
, ret
->high_slices
);
144 static void slice_mask_for_size(struct mm_struct
*mm
, int psize
, struct slice_mask
*ret
)
146 unsigned char *hpsizes
;
147 int index
, mask_index
;
152 bitmap_zero(ret
->high_slices
, SLICE_NUM_HIGH
);
154 lpsizes
= mm
->context
.low_slices_psize
;
155 for (i
= 0; i
< SLICE_NUM_LOW
; i
++)
156 if (((lpsizes
>> (i
* 4)) & 0xf) == psize
)
157 ret
->low_slices
|= 1u << i
;
159 hpsizes
= mm
->context
.high_slices_psize
;
160 for (i
= 0; i
< GET_HIGH_SLICE_INDEX(mm
->context
.addr_limit
); i
++) {
161 mask_index
= i
& 0x1;
163 if (((hpsizes
[index
] >> (mask_index
* 4)) & 0xf) == psize
)
164 __set_bit(i
, ret
->high_slices
);
168 static int slice_check_fit(struct mm_struct
*mm
,
169 struct slice_mask mask
, struct slice_mask available
)
171 DECLARE_BITMAP(result
, SLICE_NUM_HIGH
);
172 unsigned long slice_count
= GET_HIGH_SLICE_INDEX(mm
->context
.addr_limit
);
174 bitmap_and(result
, mask
.high_slices
,
175 available
.high_slices
, slice_count
);
177 return (mask
.low_slices
& available
.low_slices
) == mask
.low_slices
&&
178 bitmap_equal(result
, mask
.high_slices
, slice_count
);
181 static void slice_flush_segments(void *parm
)
183 struct mm_struct
*mm
= parm
;
186 if (mm
!= current
->active_mm
)
189 copy_mm_to_paca(current
->active_mm
);
191 local_irq_save(flags
);
192 slb_flush_and_rebolt();
193 local_irq_restore(flags
);
196 static void slice_convert(struct mm_struct
*mm
, struct slice_mask mask
, int psize
)
198 int index
, mask_index
;
199 /* Write the new slice psize bits */
200 unsigned char *hpsizes
;
202 unsigned long i
, flags
;
204 slice_dbg("slice_convert(mm=%p, psize=%d)\n", mm
, psize
);
205 slice_print_mask(" mask", mask
);
207 /* We need to use a spinlock here to protect against
208 * concurrent 64k -> 4k demotion ...
210 spin_lock_irqsave(&slice_convert_lock
, flags
);
212 lpsizes
= mm
->context
.low_slices_psize
;
213 for (i
= 0; i
< SLICE_NUM_LOW
; i
++)
214 if (mask
.low_slices
& (1u << i
))
215 lpsizes
= (lpsizes
& ~(0xful
<< (i
* 4))) |
216 (((unsigned long)psize
) << (i
* 4));
218 /* Assign the value back */
219 mm
->context
.low_slices_psize
= lpsizes
;
221 hpsizes
= mm
->context
.high_slices_psize
;
222 for (i
= 0; i
< GET_HIGH_SLICE_INDEX(mm
->context
.addr_limit
); i
++) {
223 mask_index
= i
& 0x1;
225 if (test_bit(i
, mask
.high_slices
))
226 hpsizes
[index
] = (hpsizes
[index
] &
227 ~(0xf << (mask_index
* 4))) |
228 (((unsigned long)psize
) << (mask_index
* 4));
231 slice_dbg(" lsps=%lx, hsps=%lx\n",
232 (unsigned long)mm
->context
.low_slices_psize
,
233 (unsigned long)mm
->context
.high_slices_psize
);
235 spin_unlock_irqrestore(&slice_convert_lock
, flags
);
237 copro_flush_all_slbs(mm
);
241 * Compute which slice addr is part of;
242 * set *boundary_addr to the start or end boundary of that slice
243 * (depending on 'end' parameter);
244 * return boolean indicating if the slice is marked as available in the
245 * 'available' slice_mark.
247 static bool slice_scan_available(unsigned long addr
,
248 struct slice_mask available
,
250 unsigned long *boundary_addr
)
253 if (addr
< SLICE_LOW_TOP
) {
254 slice
= GET_LOW_SLICE_INDEX(addr
);
255 *boundary_addr
= (slice
+ end
) << SLICE_LOW_SHIFT
;
256 return !!(available
.low_slices
& (1u << slice
));
258 slice
= GET_HIGH_SLICE_INDEX(addr
);
259 *boundary_addr
= (slice
+ end
) ?
260 ((slice
+ end
) << SLICE_HIGH_SHIFT
) : SLICE_LOW_TOP
;
261 return !!test_bit(slice
, available
.high_slices
);
265 static unsigned long slice_find_area_bottomup(struct mm_struct
*mm
,
267 struct slice_mask available
,
270 int pshift
= max_t(int, mmu_psize_defs
[psize
].shift
, PAGE_SHIFT
);
271 unsigned long addr
, found
, next_end
;
272 struct vm_unmapped_area_info info
;
276 info
.align_mask
= PAGE_MASK
& ((1ul << pshift
) - 1);
277 info
.align_offset
= 0;
279 addr
= TASK_UNMAPPED_BASE
;
280 while (addr
< mm
->context
.addr_limit
) {
281 info
.low_limit
= addr
;
282 if (!slice_scan_available(addr
, available
, 1, &addr
))
287 * At this point [info.low_limit; addr) covers
288 * available slices only and ends at a slice boundary.
289 * Check if we need to reduce the range, or if we can
290 * extend it to cover the next available slice.
292 if (addr
>= mm
->context
.addr_limit
)
293 addr
= mm
->context
.addr_limit
;
294 else if (slice_scan_available(addr
, available
, 1, &next_end
)) {
298 info
.high_limit
= addr
;
300 found
= vm_unmapped_area(&info
);
301 if (!(found
& ~PAGE_MASK
))
308 static unsigned long slice_find_area_topdown(struct mm_struct
*mm
,
310 struct slice_mask available
,
313 int pshift
= max_t(int, mmu_psize_defs
[psize
].shift
, PAGE_SHIFT
);
314 unsigned long addr
, found
, prev
;
315 struct vm_unmapped_area_info info
;
317 info
.flags
= VM_UNMAPPED_AREA_TOPDOWN
;
319 info
.align_mask
= PAGE_MASK
& ((1ul << pshift
) - 1);
320 info
.align_offset
= 0;
322 addr
= mm
->mmap_base
;
323 while (addr
> PAGE_SIZE
) {
324 info
.high_limit
= addr
;
325 if (!slice_scan_available(addr
- 1, available
, 0, &addr
))
330 * At this point [addr; info.high_limit) covers
331 * available slices only and starts at a slice boundary.
332 * Check if we need to reduce the range, or if we can
333 * extend it to cover the previous available slice.
335 if (addr
< PAGE_SIZE
)
337 else if (slice_scan_available(addr
- 1, available
, 0, &prev
)) {
341 info
.low_limit
= addr
;
343 found
= vm_unmapped_area(&info
);
344 if (!(found
& ~PAGE_MASK
))
349 * A failed mmap() very likely causes application failure,
350 * so fall back to the bottom-up function here. This scenario
351 * can happen with large stack limits and large mmap()
354 return slice_find_area_bottomup(mm
, len
, available
, psize
);
358 static unsigned long slice_find_area(struct mm_struct
*mm
, unsigned long len
,
359 struct slice_mask mask
, int psize
,
363 return slice_find_area_topdown(mm
, len
, mask
, psize
);
365 return slice_find_area_bottomup(mm
, len
, mask
, psize
);
368 static inline void slice_or_mask(struct slice_mask
*dst
, struct slice_mask
*src
)
370 DECLARE_BITMAP(result
, SLICE_NUM_HIGH
);
372 dst
->low_slices
|= src
->low_slices
;
373 bitmap_or(result
, dst
->high_slices
, src
->high_slices
, SLICE_NUM_HIGH
);
374 bitmap_copy(dst
->high_slices
, result
, SLICE_NUM_HIGH
);
377 static inline void slice_andnot_mask(struct slice_mask
*dst
, struct slice_mask
*src
)
379 DECLARE_BITMAP(result
, SLICE_NUM_HIGH
);
381 dst
->low_slices
&= ~src
->low_slices
;
383 bitmap_andnot(result
, dst
->high_slices
, src
->high_slices
, SLICE_NUM_HIGH
);
384 bitmap_copy(dst
->high_slices
, result
, SLICE_NUM_HIGH
);
387 #ifdef CONFIG_PPC_64K_PAGES
388 #define MMU_PAGE_BASE MMU_PAGE_64K
390 #define MMU_PAGE_BASE MMU_PAGE_4K
393 unsigned long slice_get_unmapped_area(unsigned long addr
, unsigned long len
,
394 unsigned long flags
, unsigned int psize
,
397 struct slice_mask mask
;
398 struct slice_mask good_mask
;
399 struct slice_mask potential_mask
;
400 struct slice_mask compat_mask
;
401 int fixed
= (flags
& MAP_FIXED
);
402 int pshift
= max_t(int, mmu_psize_defs
[psize
].shift
, PAGE_SHIFT
);
403 struct mm_struct
*mm
= current
->mm
;
404 unsigned long newaddr
;
407 * init different masks
410 bitmap_zero(mask
.high_slices
, SLICE_NUM_HIGH
);
412 /* silence stupid warning */;
413 potential_mask
.low_slices
= 0;
414 bitmap_zero(potential_mask
.high_slices
, SLICE_NUM_HIGH
);
416 compat_mask
.low_slices
= 0;
417 bitmap_zero(compat_mask
.high_slices
, SLICE_NUM_HIGH
);
420 BUG_ON(mm
->task_size
== 0);
421 VM_BUG_ON(radix_enabled());
423 slice_dbg("slice_get_unmapped_area(mm=%p, psize=%d...\n", mm
, psize
);
424 slice_dbg(" addr=%lx, len=%lx, flags=%lx, topdown=%d\n",
425 addr
, len
, flags
, topdown
);
427 if (len
> mm
->task_size
)
429 if (len
& ((1ul << pshift
) - 1))
431 if (fixed
&& (addr
& ((1ul << pshift
) - 1)))
433 if (fixed
&& addr
> (mm
->task_size
- len
))
436 /* If hint, make sure it matches our alignment restrictions */
437 if (!fixed
&& addr
) {
438 addr
= _ALIGN_UP(addr
, 1ul << pshift
);
439 slice_dbg(" aligned addr=%lx\n", addr
);
440 /* Ignore hint if it's too large or overlaps a VMA */
441 if (addr
> mm
->task_size
- len
||
442 !slice_area_is_free(mm
, addr
, len
))
446 /* First make up a "good" mask of slices that have the right size
449 slice_mask_for_size(mm
, psize
, &good_mask
);
450 slice_print_mask(" good_mask", good_mask
);
453 * Here "good" means slices that are already the right page size,
454 * "compat" means slices that have a compatible page size (i.e.
455 * 4k in a 64k pagesize kernel), and "free" means slices without
459 * check if fits in good | compat => OK
460 * check if fits in good | compat | free => convert free
463 * check if hint fits in good => OK
464 * check if hint fits in good | free => convert free
466 * search in good, found => OK
467 * search in good | free, found => convert free
468 * search in good | compat | free, found => convert free.
471 #ifdef CONFIG_PPC_64K_PAGES
472 /* If we support combo pages, we can allow 64k pages in 4k slices */
473 if (psize
== MMU_PAGE_64K
) {
474 slice_mask_for_size(mm
, MMU_PAGE_4K
, &compat_mask
);
476 slice_or_mask(&good_mask
, &compat_mask
);
480 /* First check hint if it's valid or if we have MAP_FIXED */
481 if (addr
!= 0 || fixed
) {
482 /* Build a mask for the requested range */
483 slice_range_to_mask(addr
, len
, &mask
);
484 slice_print_mask(" mask", mask
);
486 /* Check if we fit in the good mask. If we do, we just return,
489 if (slice_check_fit(mm
, mask
, good_mask
)) {
490 slice_dbg(" fits good !\n");
494 /* Now let's see if we can find something in the existing
495 * slices for that size
497 newaddr
= slice_find_area(mm
, len
, good_mask
, psize
, topdown
);
498 if (newaddr
!= -ENOMEM
) {
499 /* Found within the good mask, we don't have to setup,
500 * we thus return directly
502 slice_dbg(" found area at 0x%lx\n", newaddr
);
507 /* We don't fit in the good mask, check what other slices are
508 * empty and thus can be converted
510 slice_mask_for_free(mm
, &potential_mask
);
511 slice_or_mask(&potential_mask
, &good_mask
);
512 slice_print_mask(" potential", potential_mask
);
514 if ((addr
!= 0 || fixed
) && slice_check_fit(mm
, mask
, potential_mask
)) {
515 slice_dbg(" fits potential !\n");
519 /* If we have MAP_FIXED and failed the above steps, then error out */
523 slice_dbg(" search...\n");
525 /* If we had a hint that didn't work out, see if we can fit
526 * anywhere in the good area.
529 addr
= slice_find_area(mm
, len
, good_mask
, psize
, topdown
);
530 if (addr
!= -ENOMEM
) {
531 slice_dbg(" found area at 0x%lx\n", addr
);
536 /* Now let's see if we can find something in the existing slices
537 * for that size plus free slices
539 addr
= slice_find_area(mm
, len
, potential_mask
, psize
, topdown
);
541 #ifdef CONFIG_PPC_64K_PAGES
542 if (addr
== -ENOMEM
&& psize
== MMU_PAGE_64K
) {
543 /* retry the search with 4k-page slices included */
544 slice_or_mask(&potential_mask
, &compat_mask
);
545 addr
= slice_find_area(mm
, len
, potential_mask
, psize
,
553 slice_range_to_mask(addr
, len
, &mask
);
554 slice_dbg(" found potential area at 0x%lx\n", addr
);
555 slice_print_mask(" mask", mask
);
558 slice_andnot_mask(&mask
, &good_mask
);
559 slice_andnot_mask(&mask
, &compat_mask
);
560 if (mask
.low_slices
|| !bitmap_empty(mask
.high_slices
, SLICE_NUM_HIGH
)) {
561 slice_convert(mm
, mask
, psize
);
562 if (psize
> MMU_PAGE_BASE
)
563 on_each_cpu(slice_flush_segments
, mm
, 1);
568 EXPORT_SYMBOL_GPL(slice_get_unmapped_area
);
570 unsigned long arch_get_unmapped_area(struct file
*filp
,
576 return slice_get_unmapped_area(addr
, len
, flags
,
577 current
->mm
->context
.user_psize
, 0);
580 unsigned long arch_get_unmapped_area_topdown(struct file
*filp
,
581 const unsigned long addr0
,
582 const unsigned long len
,
583 const unsigned long pgoff
,
584 const unsigned long flags
)
586 return slice_get_unmapped_area(addr0
, len
, flags
,
587 current
->mm
->context
.user_psize
, 1);
590 unsigned int get_slice_psize(struct mm_struct
*mm
, unsigned long addr
)
592 unsigned char *hpsizes
;
593 int index
, mask_index
;
596 * Radix doesn't use slice, but can get enabled along with MMU_SLICE
598 if (radix_enabled()) {
599 #ifdef CONFIG_PPC_64K_PAGES
605 if (addr
< SLICE_LOW_TOP
) {
607 lpsizes
= mm
->context
.low_slices_psize
;
608 index
= GET_LOW_SLICE_INDEX(addr
);
609 return (lpsizes
>> (index
* 4)) & 0xf;
611 hpsizes
= mm
->context
.high_slices_psize
;
612 index
= GET_HIGH_SLICE_INDEX(addr
);
613 mask_index
= index
& 0x1;
614 return (hpsizes
[index
>> 1] >> (mask_index
* 4)) & 0xf;
616 EXPORT_SYMBOL_GPL(get_slice_psize
);
619 * This is called by hash_page when it needs to do a lazy conversion of
620 * an address space from real 64K pages to combo 4K pages (typically
621 * when hitting a non cacheable mapping on a processor or hypervisor
622 * that won't allow them for 64K pages).
624 * This is also called in init_new_context() to change back the user
625 * psize from whatever the parent context had it set to
626 * N.B. This may be called before mm->context.id has been set.
628 * This function will only change the content of the {low,high)_slice_psize
629 * masks, it will not flush SLBs as this shall be handled lazily by the
632 void slice_set_user_psize(struct mm_struct
*mm
, unsigned int psize
)
634 int index
, mask_index
;
635 unsigned char *hpsizes
;
636 unsigned long flags
, lpsizes
;
637 unsigned int old_psize
;
640 slice_dbg("slice_set_user_psize(mm=%p, psize=%d)\n", mm
, psize
);
642 VM_BUG_ON(radix_enabled());
643 spin_lock_irqsave(&slice_convert_lock
, flags
);
645 old_psize
= mm
->context
.user_psize
;
646 slice_dbg(" old_psize=%d\n", old_psize
);
647 if (old_psize
== psize
)
650 mm
->context
.user_psize
= psize
;
653 lpsizes
= mm
->context
.low_slices_psize
;
654 for (i
= 0; i
< SLICE_NUM_LOW
; i
++)
655 if (((lpsizes
>> (i
* 4)) & 0xf) == old_psize
)
656 lpsizes
= (lpsizes
& ~(0xful
<< (i
* 4))) |
657 (((unsigned long)psize
) << (i
* 4));
658 /* Assign the value back */
659 mm
->context
.low_slices_psize
= lpsizes
;
661 hpsizes
= mm
->context
.high_slices_psize
;
662 for (i
= 0; i
< SLICE_NUM_HIGH
; i
++) {
663 mask_index
= i
& 0x1;
665 if (((hpsizes
[index
] >> (mask_index
* 4)) & 0xf) == old_psize
)
666 hpsizes
[index
] = (hpsizes
[index
] &
667 ~(0xf << (mask_index
* 4))) |
668 (((unsigned long)psize
) << (mask_index
* 4));
674 slice_dbg(" lsps=%lx, hsps=%lx\n",
675 (unsigned long)mm
->context
.low_slices_psize
,
676 (unsigned long)mm
->context
.high_slices_psize
);
679 spin_unlock_irqrestore(&slice_convert_lock
, flags
);
682 void slice_set_range_psize(struct mm_struct
*mm
, unsigned long start
,
683 unsigned long len
, unsigned int psize
)
685 struct slice_mask mask
;
687 VM_BUG_ON(radix_enabled());
689 slice_range_to_mask(start
, len
, &mask
);
690 slice_convert(mm
, mask
, psize
);
693 #ifdef CONFIG_HUGETLB_PAGE
695 * is_hugepage_only_range() is used by generic code to verify whether
696 * a normal mmap mapping (non hugetlbfs) is valid on a given area.
698 * until the generic code provides a more generic hook and/or starts
699 * calling arch get_unmapped_area for MAP_FIXED (which our implementation
700 * here knows how to deal with), we hijack it to keep standard mappings
703 * because of that generic code limitation, MAP_FIXED mapping cannot
704 * "convert" back a slice with no VMAs to the standard page size, only
705 * get_unmapped_area() can. It would be possible to fix it here but I
706 * prefer working on fixing the generic code instead.
708 * WARNING: This will not work if hugetlbfs isn't enabled since the
709 * generic code will redefine that function as 0 in that. This is ok
710 * for now as we only use slices with hugetlbfs enabled. This should
711 * be fixed as the generic code gets fixed.
713 int is_hugepage_only_range(struct mm_struct
*mm
, unsigned long addr
,
716 struct slice_mask mask
, available
;
717 unsigned int psize
= mm
->context
.user_psize
;
722 slice_range_to_mask(addr
, len
, &mask
);
723 slice_mask_for_size(mm
, psize
, &available
);
724 #ifdef CONFIG_PPC_64K_PAGES
725 /* We need to account for 4k slices too */
726 if (psize
== MMU_PAGE_64K
) {
727 struct slice_mask compat_mask
;
728 slice_mask_for_size(mm
, MMU_PAGE_4K
, &compat_mask
);
729 slice_or_mask(&available
, &compat_mask
);
733 #if 0 /* too verbose */
734 slice_dbg("is_hugepage_only_range(mm=%p, addr=%lx, len=%lx)\n",
736 slice_print_mask(" mask", mask
);
737 slice_print_mask(" available", available
);
739 return !slice_check_fit(mm
, mask
, available
);