Lines Matching defs:mas
65 static int get_alloc_node_count(struct ma_state *mas)
68 struct maple_alloc *node = mas->alloc;
79 static void check_mas_alloc_node_count(struct ma_state *mas)
81 mas_node_count_gfp(mas, MAPLE_ALLOC_SLOTS + 1, GFP_KERNEL);
82 mas_node_count_gfp(mas, MAPLE_ALLOC_SLOTS + 3, GFP_KERNEL);
83 MT_BUG_ON(mas->tree, get_alloc_node_count(mas) != mas->alloc->total);
84 mas_destroy(mas);
99 MA_STATE(mas, mt, 0, 0);
101 check_mas_alloc_node_count(&mas);
107 mas_node_count(&mas, 3);
109 MT_BUG_ON(mt, mas_alloc_req(&mas) != 3);
111 MT_BUG_ON(mt, mas.node != MA_ERROR(-ENOMEM));
112 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
114 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
115 mn = mas_pop_node(&mas);
118 MT_BUG_ON(mt, mas.alloc == NULL);
119 MT_BUG_ON(mt, mas.alloc->slot[0] == NULL);
120 mas_push_node(&mas, mn);
121 mas_nomem(&mas, GFP_KERNEL); /* free */
128 mas_set_alloc_req(&mas, 1);
130 MT_BUG_ON(mt, mas_alloc_req(&mas) != 1);
131 mas_set_err(&mas, -ENOMEM);
133 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
135 mn = mas_pop_node(&mas);
140 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
144 mas.node = MAS_START;
145 mas_nomem(&mas, GFP_KERNEL);
147 mas_node_count(&mas, 3);
149 mas_nomem(&mas, GFP_KERNEL);
151 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
153 MT_BUG_ON(mt, mas_alloc_req(&mas) != 0);
155 MT_BUG_ON(mt, mas.alloc == NULL);
156 MT_BUG_ON(mt, mas.alloc->slot[0] == NULL);
157 MT_BUG_ON(mt, mas.alloc->slot[1] == NULL);
159 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
161 mas_nomem(&mas, GFP_KERNEL);
164 mas_set_alloc_req(&mas, 1);
165 MT_BUG_ON(mt, mas_alloc_req(&mas) != 1);
166 mas_set_err(&mas, -ENOMEM);
168 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
169 MT_BUG_ON(mt, mas_allocated(&mas) != 1);
171 mn = mas_pop_node(&mas);
173 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
177 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
178 mas_push_node(&mas, mn);
179 MT_BUG_ON(mt, mas_allocated(&mas) != 1);
180 MT_BUG_ON(mt, mas.alloc->node_count);
182 mas_set_alloc_req(&mas, 2); /* request 2 more. */
183 MT_BUG_ON(mt, mas_alloc_req(&mas) != 2);
184 mas_set_err(&mas, -ENOMEM);
185 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
186 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
187 MT_BUG_ON(mt, mas.alloc == NULL);
188 MT_BUG_ON(mt, mas.alloc->slot[0] == NULL);
189 MT_BUG_ON(mt, mas.alloc->slot[1] == NULL);
191 mn = mas_pop_node(&mas);
192 MT_BUG_ON(mt, mas_allocated(&mas) != i);
200 mas_set_alloc_req(&mas, total); /* request 2 more. */
201 MT_BUG_ON(mt, mas_alloc_req(&mas) != total);
202 mas_set_err(&mas, -ENOMEM);
203 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
223 MT_BUG_ON(mt, mas.alloc->node_count != e);
224 mn = mas_pop_node(&mas);
226 MT_BUG_ON(mt, mas_allocated(&mas) != i - 1);
234 mas_set_alloc_req(&mas, i);
235 mas_set_err(&mas, -ENOMEM);
236 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
238 mn = mas_pop_node(&mas);
239 MT_BUG_ON(mt, mas_allocated(&mas) != j - 1);
242 mas_push_node(&mas, mn);
243 MT_BUG_ON(mt, mas_allocated(&mas) != j);
244 mn = mas_pop_node(&mas);
246 MT_BUG_ON(mt, mas_allocated(&mas) != j - 1);
250 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
252 mas_set_alloc_req(&mas, i);
253 mas_set_err(&mas, -ENOMEM);
254 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
256 MT_BUG_ON(mt, mas_allocated(&mas) != i - j);
257 nodes[j] = mas_pop_node(&mas);
258 MT_BUG_ON(mt, mas_allocated(&mas) != i - j - 1);
263 mas_push_node(&mas, nodes[j]);
264 MT_BUG_ON(mt, mas_allocated(&mas) != i - j);
266 MT_BUG_ON(mt, mas_allocated(&mas) != i);
268 MT_BUG_ON(mt, mas_allocated(&mas) != i - j);
269 mn = mas_pop_node(&mas);
273 MT_BUG_ON(mt, mas_allocated(&mas) != i - j - 1);
275 MT_BUG_ON(mt, mas_nomem(&mas, GFP_KERNEL));
281 mas_node_count(&mas, total);
283 mas_nomem(&mas, GFP_KERNEL);
284 MT_BUG_ON(mt, !mas.alloc);
286 smn = mas.alloc;
296 MT_BUG_ON(mt, mas_allocated(&mas) != total);
297 mas_nomem(&mas, GFP_KERNEL); /* Free. */
299 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
301 mas_node_count(&mas, i); /* Request */
302 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
303 MT_BUG_ON(mt, mas_allocated(&mas) != i); /* check request filled */
305 mn = mas_pop_node(&mas); /* get the next node. */
311 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
316 mas_node_count(&mas, i); /* Request */
317 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
318 MT_BUG_ON(mt, mas_allocated(&mas) != i); /* check request filled */
320 mn = mas_pop_node(&mas); /* get the next node. */
326 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
341 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
342 mas_node_count(&mas, MAPLE_ALLOC_SLOTS + 1); /* Request */
343 MT_BUG_ON(mt, mas.node != MA_ERROR(-ENOMEM));
344 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
345 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 1);
346 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS);
348 mn = mas_pop_node(&mas); /* get the next node. */
351 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS);
352 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS - 1);
354 mas_push_node(&mas, mn);
355 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 1);
356 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS);
359 mas_node_count(&mas, MAPLE_ALLOC_SLOTS + 2); /* Request */
360 MT_BUG_ON(mt, mas_alloc_req(&mas) != 1);
361 MT_BUG_ON(mt, mas.node != MA_ERROR(-ENOMEM));
362 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
363 MT_BUG_ON(mt, mas_alloc_req(&mas));
364 MT_BUG_ON(mt, mas.alloc->node_count != 1);
365 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 2);
366 mn = mas_pop_node(&mas);
368 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 1);
369 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS);
370 mas_push_node(&mas, mn);
371 MT_BUG_ON(mt, mas.alloc->node_count != 1);
372 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 2);
373 mn = mas_pop_node(&mas);
378 mn = mas_pop_node(&mas);
383 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
387 mas.node = MA_ERROR(-ENOMEM);
388 mas_node_count(&mas, i); /* Request */
389 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
390 mn = mas_pop_node(&mas); /* get the next node. */
391 mas_push_node(&mas, mn); /* put it back */
392 mas_destroy(&mas);
394 mas.node = MA_ERROR(-ENOMEM);
395 mas_node_count(&mas, i); /* Request */
396 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
397 mn = mas_pop_node(&mas); /* get the next node. */
398 mn2 = mas_pop_node(&mas); /* get the next node. */
399 mas_push_node(&mas, mn); /* put them back */
400 mas_push_node(&mas, mn2);
401 mas_destroy(&mas);
403 mas.node = MA_ERROR(-ENOMEM);
404 mas_node_count(&mas, i); /* Request */
405 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
406 mn = mas_pop_node(&mas); /* get the next node. */
407 mn2 = mas_pop_node(&mas); /* get the next node. */
408 mn3 = mas_pop_node(&mas); /* get the next node. */
409 mas_push_node(&mas, mn); /* put them back */
410 mas_push_node(&mas, mn2);
411 mas_push_node(&mas, mn3);
412 mas_destroy(&mas);
414 mas.node = MA_ERROR(-ENOMEM);
415 mas_node_count(&mas, i); /* Request */
416 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
417 mn = mas_pop_node(&mas); /* get the next node. */
420 mas_destroy(&mas);
422 mas.node = MA_ERROR(-ENOMEM);
423 mas_node_count(&mas, i); /* Request */
424 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
425 mn = mas_pop_node(&mas); /* get the next node. */
428 mn = mas_pop_node(&mas); /* get the next node. */
431 mn = mas_pop_node(&mas); /* get the next node. */
434 mas_destroy(&mas);
437 mas.node = MA_ERROR(-ENOMEM);
438 mas_node_count(&mas, 5); /* Request */
439 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
440 MT_BUG_ON(mt, mas_allocated(&mas) != 5);
441 mas.node = MA_ERROR(-ENOMEM);
442 mas_node_count(&mas, 10); /* Request */
443 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
444 mas.node = MAS_START;
445 MT_BUG_ON(mt, mas_allocated(&mas) != 10);
446 mas_destroy(&mas);
448 mas.node = MA_ERROR(-ENOMEM);
449 mas_node_count(&mas, MAPLE_ALLOC_SLOTS - 1); /* Request */
450 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
451 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS - 1);
452 mas.node = MA_ERROR(-ENOMEM);
453 mas_node_count(&mas, 10 + MAPLE_ALLOC_SLOTS - 1); /* Request */
454 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
455 mas.node = MAS_START;
456 MT_BUG_ON(mt, mas_allocated(&mas) != 10 + MAPLE_ALLOC_SLOTS - 1);
457 mas_destroy(&mas);
808 * @mas: The maple state
816 static inline void mas_node_walk(struct ma_state *mas, struct maple_node *node,
828 (*range_max) = (*range_min) = mas->index;
832 mas->offset = mas->index = mas->min;
842 prev = mas->min;
843 index = mas->index;
862 max = mas->max;
866 mas->offset = offset;
871 mas->max = max;
872 mas->min = prev;
877 * mas_descend_walk(): Locates a value and sets the mas->node and slot
880 * @mas: The maple state
884 * Check mas->node is still valid on return of any value.
888 static inline bool mas_descend_walk(struct ma_state *mas,
895 next = mas->node;
899 mas_node_walk(mas, node, type, range_min, range_max);
900 next = mas_slot(mas, ma_slots(node, type), mas->offset);
908 mas->node = next;
914 * mas_tree_walk() - Walk to @mas->index and set the range values.
915 * @mas: The maple state.
919 * Ranges are only valid if there is a valid entry at @mas->index.
923 static inline bool mas_tree_walk(struct ma_state *mas, unsigned long *range_min,
930 mas_start(mas);
931 if (mas_is_none(mas))
934 if (mas_is_ptr(mas)) {
936 if (!mas->index)
942 ret = mas_descend_walk(mas, range_min, range_max);
943 if (unlikely(mte_dead_node(mas->node))) {
944 mas->node = MAS_START;
951 mas->offset = MAPLE_NODE_SLOTS;
955 static inline void *mas_range_load(struct ma_state *mas,
960 unsigned long index = mas->index;
962 if (mas_is_none(mas) || mas_is_paused(mas))
963 mas->node = MAS_START;
965 if (mas_tree_walk(mas, range_min, range_max))
966 if (unlikely(mas->node == MAS_ROOT))
967 return mas_root(mas);
969 if (likely(mas->offset != MAPLE_NODE_SLOTS))
970 entry = mas_get_slot(mas, mas->offset);
972 if (mas_dead_node(mas, index))
988 MA_STATE(mas, mt, 0, 0);
1089 mas_reset(&mas);
1090 mas.index = 0;
1092 mas_for_each(&mas, foo, ULONG_MAX) {
1094 if (addr == mas.index) {
1095 mt_dump(mas.tree, mt_dump_hex);
1097 mas.index, mas.last);
1100 addr = mas.index;
1104 pr_err("mas: %lu -> %p\n", mas.index, foo);
1118 MT_BUG_ON(mt, mtree_load(mas.tree, 0) != NULL);
33866 * mmap: mas.min 4041154560 max 4041191423 mas.last 4041191423
33867 * mmap: mas.index 4041162752 align mask 0 offset 0
33896 MA_STATE(mas, mt, 0, 0);
33918 mas_for_each(&mas, entry, ULONG_MAX) {
33958 mas_reset(&mas);
33962 mas_empty_area_rev(&mas, 12288, 140014592737280, 0x2000);
33963 MT_BUG_ON(mt, mas.last != 140014592573439);
33966 mas_reset(&mas);
33967 mas.tree = mt;
33969 mas.index = 0;
33973 mas_for_each(&mas, entry, ULONG_MAX) {
33981 mas_reset(&mas);
33986 mas_empty_area_rev(&mas, 0, 140373518663680, 4096);
34001 mas_reset(&mas);
34005 mas_empty_area_rev(&mas, 4096, 139921865637888, 0x6000);
34006 MT_BUG_ON(mt, mas.last != 139921865547775);
34016 mas_reset(&mas);
34020 mas_empty_area_rev(&mas, 4096, 139953197334528, 0x1000);
34021 MT_BUG_ON(mt, mas.last != 139953197322239);
34022 /* MT_BUG_ON(mt, mas.index != 139953197318144); */
34032 mas_reset(&mas);
34036 mas_empty_area_rev(&mas, 4096, 140222972858368, 2215936);
34037 MT_BUG_ON(mt, mas.last != 140222968475647);
34038 /*MT_BUG_ON(mt, mas.index != 140222966259712); */
34050 mas_reset(&mas);
34054 mas.index = 140656779083776;
34055 entry = mas_find(&mas, ULONG_MAX);
34057 entry = mas_prev(&mas, 0);
34119 mas_reset(&mas);
34123 mas_empty_area_rev(&mas, 4096, 140109042671616, 409600);
34124 MT_BUG_ON(mt, mas.last != 140109040959487);
34131 mas_reset(&mas);
34141 mas_reset(&mas);
34145 mas_empty_area_rev(&mas, 4096, 139918413357056, 2097152);
34147 mas.index = (mas.last + 1 - 2097152 - 0) & (~2093056);
34148 MT_BUG_ON(mt, mas.index != 139918401601536);
34157 mas_reset(&mas);
34170 mas_reset(&mas);
34183 mas_reset(&mas);
34192 mas_reset(&mas);
34204 * mmap: mas.min 94133881868288 max 140582961786879 mas.last 140582961786879
34205 * mmap: mas.index 140582827569152 align mask 0 offset 0
34212 mas_reset(&mas);
34216 mas_empty_area_rev(&mas, 4096, 140583656296448, 134217728);
34217 MT_BUG_ON(mt, mas.last != 140583003750399);
34227 mas_reset(&mas);
34237 mas_reset(&mas);
34247 mas_reset(&mas);
34255 mas_reset(&mas);
34263 mas_reset(&mas);
34271 mas_reset(&mas);
34278 mas_reset(&mas);
34285 mas_reset(&mas);
34294 mas_reset(&mas);
34298 mas_empty_area_rev(&mas, 4096, 4052029440, 28672);
34299 MT_BUG_ON(mt, mas.last != 4041211903);
34306 mas_reset(&mas);
34351 MA_STATE(mas, test->mt, 0, 0);
34360 mas_set(&mas, test->index[index]);
34361 mas_for_each(&mas, entry, test->last[index + 9]) {
34373 if (mas.index == alt_start) {
34388 if (mas.index == r_start) {
34391 } else if (mas.index == alt_start) {
34399 RCU_MT_BUG_ON(test, mas.index != r_start);
34400 RCU_MT_BUG_ON(test, mas.last != r_end);
34416 printk("!!%lu-%lu -> %p not %p or %p\n", mas.index, mas.last, entry, expected, alt);
34439 printk("!!%lu-%lu -> %p not %p\n", mas.index, mas.last, entry, expected);
34461 MA_STATE(mas, test->mt, 0, 0);
34471 mas_set(&mas, test->index[index + i]);
34479 entry = mas_prev(&mas, test->index[index]);
34486 if (mas.index == alt_start) {
34502 if (mas.index == r_start) {
34506 } else if (mas.index == alt_start) {
34520 if (mas.index != r_start) {
34525 mas.index, mas.last, entry,
34529 RCU_MT_BUG_ON(test, mas.index != r_start);
34530 RCU_MT_BUG_ON(test, mas.last != r_end);
34565 mas.index, mas.last, entry,
34573 printk("%lu-%lu %p != %p\n", mas.index,
34574 mas.last, entry, expected);
34890 MA_STATE(mas, test->mt, test->range_start, test->range_start);
34901 mas_for_each(&mas, entry, test->range_end) {
34903 expected = xa_mk_value(mas.index ? mas.index / 10 : 0);
34906 if (mas.index < test->index || mas.index > test->last) {
34909 mas.index, mas.last, entry, expected);
34924 mas_set(&mas, test->range_start);
34967 MA_STATE(mas, test->mt, test->index, test->index);
34973 mas_walk(&mas);
34975 RCU_MT_BUG_ON(test, (test->index - mas.index) !=
34976 (mas.last - test->last));
35332 static void mas_dfs_preorder(struct ma_state *mas)
35339 if (mas->node == MAS_START) {
35340 mas_start(mas);
35344 if (mte_is_leaf(mas->node) && mte_is_root(mas->node))
35348 end = mas_data_end(mas);
35349 if (mte_is_leaf(mas->node) ||
35351 if (mte_is_root(mas->node))
35354 slot = mte_parent_slot(mas->node) + 1;
35355 mas_ascend(mas);
35359 prev = mas->node;
35360 mas->node = mas_get_slot(mas, slot);
35361 if (!mas->node || slot > end) {
35365 mas->node = prev;
35366 slot = mte_parent_slot(mas->node) + 1;
35367 mas_ascend(mas);
35371 mas->max = mas_safe_pivot(mas, pivots, slot, mte_node_type(prev));
35372 mas->min = mas_safe_min(mas, pivots, slot);
35376 mas->node = MAS_NONE;
35384 MA_STATE(mas, mt, 0, 0);
35394 mas_dfs_preorder(&mas);
35395 } while (!mas_is_none(&mas));
35400 mas_reset(&mas);
35408 mas_dfs_preorder(&mas);
35409 } while (!mas_is_none(&mas));
35415 mas_reset(&mas);
35420 mas_dfs_preorder(&mas);
35421 } while (!mas_is_none(&mas));
35427 mas_reset(&mas);
35430 mas_expected_entries(&mas, max);
35432 mas.index = mas.last = count;
35433 mas_store(&mas, xa_mk_value(count));
35434 MT_BUG_ON(mt, mas_is_err(&mas));
35436 mas_destroy(&mas);
35455 MA_STATE(mas, mt, 10, 20);
35462 mas_set_range(&mas, 470, 500);
35463 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35464 allocated = mas_allocated(&mas);
35465 height = mas_mt_height(&mas);
35468 mas_destroy(&mas);
35469 allocated = mas_allocated(&mas);
35472 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35473 allocated = mas_allocated(&mas);
35474 height = mas_mt_height(&mas);
35477 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35478 mas_destroy(&mas);
35479 allocated = mas_allocated(&mas);
35483 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35484 allocated = mas_allocated(&mas);
35485 height = mas_mt_height(&mas);
35487 mn = mas_pop_node(&mas);
35488 MT_BUG_ON(mt, mas_allocated(&mas) != allocated - 1);
35491 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35492 mas_destroy(&mas);
35493 allocated = mas_allocated(&mas);
35496 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35497 allocated = mas_allocated(&mas);
35498 height = mas_mt_height(&mas);
35500 mn = mas_pop_node(&mas);
35501 MT_BUG_ON(mt, mas_allocated(&mas) != allocated - 1);
35502 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35503 mas_destroy(&mas);
35504 allocated = mas_allocated(&mas);
35509 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35510 allocated = mas_allocated(&mas);
35511 height = mas_mt_height(&mas);
35513 mn = mas_pop_node(&mas);
35514 MT_BUG_ON(mt, mas_allocated(&mas) != allocated - 1);
35515 mas_push_node(&mas, mn);
35516 MT_BUG_ON(mt, mas_allocated(&mas) != allocated);
35517 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35518 mas_destroy(&mas);
35519 allocated = mas_allocated(&mas);
35522 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35523 allocated = mas_allocated(&mas);
35524 height = mas_mt_height(&mas);
35526 mas_store_prealloc(&mas, ptr);
35527 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35530 mas_set_range(&mas, 6, 9);
35531 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35532 allocated = mas_allocated(&mas);
35534 mas_store_prealloc(&mas, ptr);
35535 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35537 mas_set_range(&mas, 6, 10);
35538 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35539 allocated = mas_allocated(&mas);
35540 height = mas_mt_height(&mas);
35542 mas_store_prealloc(&mas, ptr);
35543 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35546 mas_set_range(&mas, 54, 54);
35547 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35548 allocated = mas_allocated(&mas);
35549 height = mas_mt_height(&mas);
35551 mas_store_prealloc(&mas, ptr);
35552 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35555 mas_set_range(&mas, 1, 100);
35556 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL & GFP_NOWAIT) == 0);
35557 allocated = mas_allocated(&mas);
35558 height = mas_mt_height(&mas);
35560 mas_destroy(&mas);
35564 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35565 allocated = mas_allocated(&mas);
35566 height = mas_mt_height(&mas);
35569 mas_store_prealloc(&mas, ptr);
35570 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35571 mas_set_range(&mas, 0, 200);
35573 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL & GFP_NOWAIT) == 0);
35574 allocated = mas_allocated(&mas);
35575 height = mas_mt_height(&mas);
35584 MA_STATE(mas, mt, 1200, 2380);
35590 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35591 mas_set(&mas, 1205);
35592 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35600 mas_set_range(&mas, 9, 50006); /* Will expand to 0 - ULONG_MAX */
35601 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35602 mas_set(&mas, 1205);
35603 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35613 mas_set_range(&mas, 0, 12900); /* Spans more than 2 levels */
35615 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35616 mas_set(&mas, 1205);
35617 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35626 mas_set_range(&mas, 0, 300);
35628 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35629 mas_set(&mas, 15);
35630 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35639 mas_set_range(&mas, 0, 12865);
35641 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35642 mas_set(&mas, 15);
35643 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35652 mas_set_range(&mas, 90, 13665);
35654 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35655 mas_set(&mas, 95);
35656 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35665 mas_set_range(&mas, 46805, 49995);
35667 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35668 mas_set(&mas, 46815);
35669 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35681 mas_set_range(&mas, 32395, 49995);
35683 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35684 mas_set(&mas, 46815);
35685 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35696 mas_set_range(&mas, 38875, 43190);
35698 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35699 mas_set(&mas, 38900);
35700 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35709 mas_set(&mas, 47606);
35710 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35711 mas_set(&mas, 47607);
35712 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35713 mas_set(&mas, 47608);
35714 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35715 mas_set(&mas, 47609);
35716 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35718 mas_ascend(&mas);
35719 MT_BUG_ON(mt, (mas_data_end(&mas)) != mt_slot_count(mas.node) - 1);
35720 mas_set_range(&mas, 11516, 48940);
35721 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35729 mas_set_range(&mas, 43200, 49999);
35731 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35732 mas_set(&mas, 43200);
35733 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35742 mas_set_range(&mas, 76, 875);
35743 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35753 MA_STATE(mas, mt, 959, 959);
35758 mas_lock(&mas);
35759 mas_walk(&mas);
35760 data_end = mas_data_end(&mas);
35761 mas_set_range(&mas, 959, 963);
35762 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35764 MT_BUG_ON(mt, data_end != mas_data_end(&mas));
35767 mas_set(&mas, 880);
35768 mas_walk(&mas);
35769 data_end = mas_data_end(&mas);
35770 mas_set_range(&mas, 884, 887);
35771 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35775 MT_BUG_ON(mt, data_end != mas_data_end(&mas));
35779 mas_set(&mas, 890);
35780 mas_walk(&mas);
35781 data_end = mas_data_end(&mas);
35782 mas_set_range(&mas, 900, 905);
35783 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35789 MT_BUG_ON(mt, data_end - 2 != mas_data_end(&mas));
35793 mas_set(&mas, 800);
35794 mas_walk(&mas);
35795 data_end = mas_data_end(&mas);
35796 mas_set_range(&mas, 810, 825);
35797 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35803 MT_BUG_ON(mt, data_end - 4 != mas_data_end(&mas));
35805 mas_unlock(&mas);