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_reset(&mas);
122 mas_nomem(&mas, GFP_KERNEL); /* free */
129 mas_set_alloc_req(&mas, 1);
131 MT_BUG_ON(mt, mas_alloc_req(&mas) != 1);
132 mas_set_err(&mas, -ENOMEM);
134 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
136 mn = mas_pop_node(&mas);
141 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
145 mas.status = ma_start;
146 mas_nomem(&mas, GFP_KERNEL);
148 mas_node_count(&mas, 3);
150 mas_nomem(&mas, GFP_KERNEL);
152 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
154 MT_BUG_ON(mt, mas_alloc_req(&mas) != 0);
156 MT_BUG_ON(mt, mas.alloc == NULL);
157 MT_BUG_ON(mt, mas.alloc->slot[0] == NULL);
158 MT_BUG_ON(mt, mas.alloc->slot[1] == NULL);
160 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
162 mas_reset(&mas);
163 mas_nomem(&mas, GFP_KERNEL);
166 mas_set_alloc_req(&mas, 1);
167 MT_BUG_ON(mt, mas_alloc_req(&mas) != 1);
168 mas_set_err(&mas, -ENOMEM);
170 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
171 MT_BUG_ON(mt, mas_allocated(&mas) != 1);
173 mn = mas_pop_node(&mas);
175 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
179 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
180 mas_push_node(&mas, mn);
181 MT_BUG_ON(mt, mas_allocated(&mas) != 1);
182 MT_BUG_ON(mt, mas.alloc->node_count);
184 mas_set_alloc_req(&mas, 2); /* request 2 more. */
185 MT_BUG_ON(mt, mas_alloc_req(&mas) != 2);
186 mas_set_err(&mas, -ENOMEM);
187 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
188 MT_BUG_ON(mt, mas_allocated(&mas) != 3);
189 MT_BUG_ON(mt, mas.alloc == NULL);
190 MT_BUG_ON(mt, mas.alloc->slot[0] == NULL);
191 MT_BUG_ON(mt, mas.alloc->slot[1] == NULL);
193 mn = mas_pop_node(&mas);
194 MT_BUG_ON(mt, mas_allocated(&mas) != i);
202 mas_set_alloc_req(&mas, total); /* request 2 more. */
203 MT_BUG_ON(mt, mas_alloc_req(&mas) != total);
204 mas_set_err(&mas, -ENOMEM);
205 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
225 MT_BUG_ON(mt, mas.alloc->node_count != e);
226 mn = mas_pop_node(&mas);
228 MT_BUG_ON(mt, mas_allocated(&mas) != i - 1);
236 mas_set_alloc_req(&mas, i);
237 mas_set_err(&mas, -ENOMEM);
238 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
240 mn = mas_pop_node(&mas);
241 MT_BUG_ON(mt, mas_allocated(&mas) != j - 1);
244 mas_push_node(&mas, mn);
245 MT_BUG_ON(mt, mas_allocated(&mas) != j);
246 mn = mas_pop_node(&mas);
248 MT_BUG_ON(mt, mas_allocated(&mas) != j - 1);
252 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
254 mas_set_alloc_req(&mas, i);
255 mas_set_err(&mas, -ENOMEM);
256 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
258 MT_BUG_ON(mt, mas_allocated(&mas) != i - j);
259 nodes[j] = mas_pop_node(&mas);
260 MT_BUG_ON(mt, mas_allocated(&mas) != i - j - 1);
265 mas_push_node(&mas, nodes[j]);
266 MT_BUG_ON(mt, mas_allocated(&mas) != i - j);
268 MT_BUG_ON(mt, mas_allocated(&mas) != i);
270 MT_BUG_ON(mt, mas_allocated(&mas) != i - j);
271 mn = mas_pop_node(&mas);
275 MT_BUG_ON(mt, mas_allocated(&mas) != i - j - 1);
277 mas_reset(&mas);
278 MT_BUG_ON(mt, mas_nomem(&mas, GFP_KERNEL));
284 mas_node_count(&mas, total);
286 mas_nomem(&mas, GFP_KERNEL);
287 MT_BUG_ON(mt, !mas.alloc);
289 smn = mas.alloc;
299 MT_BUG_ON(mt, mas_allocated(&mas) != total);
300 mas_reset(&mas);
301 mas_nomem(&mas, GFP_KERNEL); /* Free. */
303 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
305 mas_node_count(&mas, i); /* Request */
306 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
307 MT_BUG_ON(mt, mas_allocated(&mas) != i); /* check request filled */
309 mn = mas_pop_node(&mas); /* get the next node. */
315 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
320 mas_node_count(&mas, i); /* Request */
321 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
322 MT_BUG_ON(mt, mas_allocated(&mas) != i); /* check request filled */
324 mn = mas_pop_node(&mas); /* get the next node. */
330 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
345 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
346 mas_node_count(&mas, MAPLE_ALLOC_SLOTS + 1); /* Request */
347 MT_BUG_ON(mt, mas.node != MA_ERROR(-ENOMEM));
348 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
349 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 1);
350 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS);
352 mn = mas_pop_node(&mas); /* get the next node. */
355 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS);
356 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS - 1);
358 mas_push_node(&mas, mn);
359 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 1);
360 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS);
363 mas_node_count(&mas, MAPLE_ALLOC_SLOTS + 2); /* Request */
364 MT_BUG_ON(mt, mas_alloc_req(&mas) != 1);
365 MT_BUG_ON(mt, mas.node != MA_ERROR(-ENOMEM));
366 MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
367 MT_BUG_ON(mt, mas_alloc_req(&mas));
368 MT_BUG_ON(mt, mas.alloc->node_count != 1);
369 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 2);
370 mn = mas_pop_node(&mas);
372 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 1);
373 MT_BUG_ON(mt, mas.alloc->node_count != MAPLE_ALLOC_SLOTS);
374 mas_push_node(&mas, mn);
375 MT_BUG_ON(mt, mas.alloc->node_count != 1);
376 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS + 2);
377 mn = mas_pop_node(&mas);
382 mn = mas_pop_node(&mas);
387 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
391 mas.node = MA_ERROR(-ENOMEM);
392 mas_node_count(&mas, i); /* Request */
393 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
394 mn = mas_pop_node(&mas); /* get the next node. */
395 mas_push_node(&mas, mn); /* put it back */
396 mas_destroy(&mas);
398 mas.node = MA_ERROR(-ENOMEM);
399 mas_node_count(&mas, i); /* Request */
400 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
401 mn = mas_pop_node(&mas); /* get the next node. */
402 mn2 = mas_pop_node(&mas); /* get the next node. */
403 mas_push_node(&mas, mn); /* put them back */
404 mas_push_node(&mas, mn2);
405 mas_destroy(&mas);
407 mas.node = MA_ERROR(-ENOMEM);
408 mas_node_count(&mas, i); /* Request */
409 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
410 mn = mas_pop_node(&mas); /* get the next node. */
411 mn2 = mas_pop_node(&mas); /* get the next node. */
412 mn3 = mas_pop_node(&mas); /* get the next node. */
413 mas_push_node(&mas, mn); /* put them back */
414 mas_push_node(&mas, mn2);
415 mas_push_node(&mas, mn3);
416 mas_destroy(&mas);
418 mas.node = MA_ERROR(-ENOMEM);
419 mas_node_count(&mas, i); /* Request */
420 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
421 mn = mas_pop_node(&mas); /* get the next node. */
424 mas_destroy(&mas);
426 mas.node = MA_ERROR(-ENOMEM);
427 mas_node_count(&mas, i); /* Request */
428 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
429 mn = mas_pop_node(&mas); /* get the next node. */
432 mn = mas_pop_node(&mas); /* get the next node. */
435 mn = mas_pop_node(&mas); /* get the next node. */
438 mas_destroy(&mas);
441 mas.node = MA_ERROR(-ENOMEM);
442 mas_node_count(&mas, 5); /* Request */
443 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
444 MT_BUG_ON(mt, mas_allocated(&mas) != 5);
445 mas.node = MA_ERROR(-ENOMEM);
446 mas_node_count(&mas, 10); /* Request */
447 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
448 mas.status = ma_start;
449 MT_BUG_ON(mt, mas_allocated(&mas) != 10);
450 mas_destroy(&mas);
452 mas.node = MA_ERROR(-ENOMEM);
453 mas_node_count(&mas, MAPLE_ALLOC_SLOTS - 1); /* Request */
454 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
455 MT_BUG_ON(mt, mas_allocated(&mas) != MAPLE_ALLOC_SLOTS - 1);
456 mas.node = MA_ERROR(-ENOMEM);
457 mas_node_count(&mas, 10 + MAPLE_ALLOC_SLOTS - 1); /* Request */
458 mas_nomem(&mas, GFP_KERNEL); /* Fill request */
459 mas.status = ma_start;
460 MT_BUG_ON(mt, mas_allocated(&mas) != 10 + MAPLE_ALLOC_SLOTS - 1);
461 mas_destroy(&mas);
812 * @mas: The maple state
820 static inline void mas_node_walk(struct ma_state *mas, struct maple_node *node,
832 (*range_max) = (*range_min) = mas->index;
836 mas->offset = mas->index = mas->min;
846 prev = mas->min;
847 index = mas->index;
866 max = mas->max;
870 mas->offset = offset;
875 mas->max = max;
876 mas->min = prev;
881 * mas_descend_walk(): Locates a value and sets the mas->node and slot
884 * @mas: The maple state
888 * Check mas->node is still valid on return of any value.
892 static inline bool mas_descend_walk(struct ma_state *mas,
899 next = mas->node;
903 mas_node_walk(mas, node, type, range_min, range_max);
904 next = mas_slot(mas, ma_slots(node, type), mas->offset);
912 mas->node = next;
918 * mas_tree_walk() - Walk to @mas->index and set the range values.
919 * @mas: The maple state.
923 * Ranges are only valid if there is a valid entry at @mas->index.
927 static inline bool mas_tree_walk(struct ma_state *mas, unsigned long *range_min,
934 mas_start(mas);
935 if (mas_is_none(mas))
938 if (mas_is_ptr(mas)) {
940 if (!mas->index)
946 ret = mas_descend_walk(mas, range_min, range_max);
947 if (unlikely(mte_dead_node(mas->node))) {
948 mas->status = ma_start;
952 mas->end = mas_data_end(mas);
956 mas->offset = MAPLE_NODE_SLOTS;
960 static inline void *mas_range_load(struct ma_state *mas,
965 unsigned long index = mas->index;
967 if (mas_is_none(mas) || mas_is_paused(mas))
968 mas->status = ma_start;
970 if (mas_tree_walk(mas, range_min, range_max))
971 if (unlikely(mas->status == ma_root))
972 return mas_root(mas);
974 if (likely(mas->offset != MAPLE_NODE_SLOTS))
975 entry = mas_get_slot(mas, mas->offset);
977 if (mas_is_active(mas) && mte_dead_node(mas->node)) {
978 mas_set(mas, index);
995 MA_STATE(mas, mt, 0, 0);
1096 mas_reset(&mas);
1097 mas.index = 0;
1099 mas_for_each(&mas, foo, ULONG_MAX) {
1101 if (addr == mas.index) {
1102 mt_dump(mas.tree, mt_dump_hex);
1104 mas.index, mas.last);
1107 addr = mas.index;
1111 pr_err("mas: %lu -> %p\n", mas.index, foo);
1125 MT_BUG_ON(mt, mtree_load(mas.tree, 0) != NULL);
33873 * mmap: mas.min 4041154560 max 4041191423 mas.last 4041191423
33874 * mmap: mas.index 4041162752 align mask 0 offset 0
33903 MA_STATE(mas, mt, 0, 0);
33925 mas_for_each(&mas, entry, ULONG_MAX) {
33965 mas_reset(&mas);
33969 mas_empty_area_rev(&mas, 12288, 140014592737280, 0x2000);
33970 MT_BUG_ON(mt, mas.last != 140014592573439);
33973 mas_reset(&mas);
33974 mas.tree = mt;
33976 mas.index = 0;
33980 mas_for_each(&mas, entry, ULONG_MAX) {
33988 mas_reset(&mas);
33993 mas_empty_area_rev(&mas, 0, 140373518663680, 4096);
34008 mas_reset(&mas);
34012 mas_empty_area_rev(&mas, 4096, 139921865637888, 0x6000);
34013 MT_BUG_ON(mt, mas.last != 139921865547775);
34023 mas_reset(&mas);
34027 mas_empty_area_rev(&mas, 4096, 139953197334528, 0x1000);
34028 MT_BUG_ON(mt, mas.last != 139953197322239);
34029 /* MT_BUG_ON(mt, mas.index != 139953197318144); */
34039 mas_reset(&mas);
34043 mas_empty_area_rev(&mas, 4096, 140222972858368, 2215936);
34044 MT_BUG_ON(mt, mas.last != 140222968475647);
34045 /*MT_BUG_ON(mt, mas.index != 140222966259712); */
34057 mas_reset(&mas);
34061 mas.index = 140656779083776;
34062 entry = mas_find(&mas, ULONG_MAX);
34064 entry = mas_prev(&mas, 0);
34126 mas_reset(&mas);
34130 mas_empty_area_rev(&mas, 4096, 140109042671616, 409600);
34131 MT_BUG_ON(mt, mas.last != 140109040959487);
34138 mas_reset(&mas);
34148 mas_reset(&mas);
34152 mas_empty_area_rev(&mas, 4096, 139918413357056, 2097152);
34154 mas.index = (mas.last + 1 - 2097152 - 0) & (~2093056);
34155 MT_BUG_ON(mt, mas.index != 139918401601536);
34164 mas_reset(&mas);
34177 mas_reset(&mas);
34190 mas_reset(&mas);
34199 mas_reset(&mas);
34211 * mmap: mas.min 94133881868288 max 140582961786879 mas.last 140582961786879
34212 * mmap: mas.index 140582827569152 align mask 0 offset 0
34219 mas_reset(&mas);
34223 mas_empty_area_rev(&mas, 4096, 140583656296448, 134217728);
34224 MT_BUG_ON(mt, mas.last != 140583003750399);
34234 mas_reset(&mas);
34244 mas_reset(&mas);
34254 mas_reset(&mas);
34262 mas_reset(&mas);
34270 mas_reset(&mas);
34278 mas_reset(&mas);
34285 mas_reset(&mas);
34292 mas_reset(&mas);
34301 mas_reset(&mas);
34305 mas_empty_area_rev(&mas, 4096, 4052029440, 28672);
34306 MT_BUG_ON(mt, mas.last != 4041211903);
34313 mas_reset(&mas);
34358 MA_STATE(mas, test->mt, 0, 0);
34367 mas_set(&mas, test->index[index]);
34368 mas_for_each(&mas, entry, test->last[index + 9]) {
34380 if (mas.index == alt_start) {
34395 if (mas.index == r_start) {
34398 } else if (mas.index == alt_start) {
34406 RCU_MT_BUG_ON(test, mas.index != r_start);
34407 RCU_MT_BUG_ON(test, mas.last != r_end);
34423 printk("!!%lu-%lu -> %p not %p or %p\n", mas.index, mas.last, entry, expected, alt);
34446 printk("!!%lu-%lu -> %p not %p\n", mas.index, mas.last, entry, expected);
34468 MA_STATE(mas, test->mt, 0, 0);
34478 mas_set(&mas, test->index[index + i]);
34486 entry = mas_prev(&mas, test->index[index]);
34493 if (mas.index == alt_start) {
34509 if (mas.index == r_start) {
34513 } else if (mas.index == alt_start) {
34527 if (mas.index != r_start) {
34532 mas.index, mas.last, entry,
34536 RCU_MT_BUG_ON(test, mas.index != r_start);
34537 RCU_MT_BUG_ON(test, mas.last != r_end);
34572 mas.index, mas.last, entry,
34580 printk("%lu-%lu %p != %p\n", mas.index,
34581 mas.last, entry, expected);
34897 MA_STATE(mas, test->mt, test->range_start, test->range_start);
34908 mas_for_each(&mas, entry, test->range_end) {
34910 expected = xa_mk_value(mas.index ? mas.index / 10 : 0);
34913 if (mas.index < test->index || mas.index > test->last) {
34916 mas.index, mas.last, entry, expected);
34931 mas_set(&mas, test->range_start);
34974 MA_STATE(mas, test->mt, test->index, test->index);
34980 mas_walk(&mas);
34982 RCU_MT_BUG_ON(test, (test->index - mas.index) !=
34983 (mas.last - test->last));
35339 static void mas_dfs_preorder(struct ma_state *mas)
35346 if (mas->status == ma_start) {
35347 mas_start(mas);
35351 if (mte_is_leaf(mas->node) && mte_is_root(mas->node))
35355 end = mas_data_end(mas);
35356 if (mte_is_leaf(mas->node) ||
35358 if (mte_is_root(mas->node))
35361 slot = mte_parent_slot(mas->node) + 1;
35362 mas_ascend(mas);
35366 prev = mas->node;
35367 mas->node = mas_get_slot(mas, slot);
35368 if (!mas->node || slot > end) {
35372 mas->node = prev;
35373 slot = mte_parent_slot(mas->node) + 1;
35374 mas_ascend(mas);
35378 mas->max = mas_safe_pivot(mas, pivots, slot, mte_node_type(prev));
35379 mas->min = mas_safe_min(mas, pivots, slot);
35383 mas->status = ma_none;
35391 MA_STATE(mas, mt, 0, 0);
35401 mas_dfs_preorder(&mas);
35402 } while (!mas_is_none(&mas));
35407 mas_reset(&mas);
35415 mas_dfs_preorder(&mas);
35416 } while (!mas_is_none(&mas));
35422 mas_reset(&mas);
35427 mas_dfs_preorder(&mas);
35428 } while (!mas_is_none(&mas));
35434 mas_reset(&mas);
35437 mas_expected_entries(&mas, max);
35439 mas.index = mas.last = count;
35440 mas_store(&mas, xa_mk_value(count));
35441 MT_BUG_ON(mt, mas_is_err(&mas));
35443 mas_destroy(&mas);
35462 MA_STATE(mas, mt, 10, 20);
35469 mas_set_range(&mas, 470, 500);
35470 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35471 allocated = mas_allocated(&mas);
35472 height = mas_mt_height(&mas);
35475 mas_destroy(&mas);
35476 allocated = mas_allocated(&mas);
35479 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35480 allocated = mas_allocated(&mas);
35481 height = mas_mt_height(&mas);
35484 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35485 mas_destroy(&mas);
35486 allocated = mas_allocated(&mas);
35490 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35491 allocated = mas_allocated(&mas);
35492 height = mas_mt_height(&mas);
35494 mn = mas_pop_node(&mas);
35495 MT_BUG_ON(mt, mas_allocated(&mas) != allocated - 1);
35498 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35499 mas_destroy(&mas);
35500 allocated = mas_allocated(&mas);
35503 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35504 allocated = mas_allocated(&mas);
35505 height = mas_mt_height(&mas);
35507 mn = mas_pop_node(&mas);
35508 MT_BUG_ON(mt, mas_allocated(&mas) != allocated - 1);
35509 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35510 mas_destroy(&mas);
35511 allocated = mas_allocated(&mas);
35516 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35517 allocated = mas_allocated(&mas);
35518 height = mas_mt_height(&mas);
35520 mn = mas_pop_node(&mas);
35521 MT_BUG_ON(mt, mas_allocated(&mas) != allocated - 1);
35522 mas_push_node(&mas, mn);
35523 MT_BUG_ON(mt, mas_allocated(&mas) != allocated);
35524 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35525 mas_destroy(&mas);
35526 allocated = mas_allocated(&mas);
35529 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35530 allocated = mas_allocated(&mas);
35531 height = mas_mt_height(&mas);
35533 mas_store_prealloc(&mas, ptr);
35534 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35537 mas_set_range(&mas, 6, 9);
35538 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35539 allocated = mas_allocated(&mas);
35541 mas_store_prealloc(&mas, ptr);
35542 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35544 mas_set_range(&mas, 6, 10);
35545 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35546 allocated = mas_allocated(&mas);
35547 height = mas_mt_height(&mas);
35549 mas_store_prealloc(&mas, ptr);
35550 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35553 mas_set_range(&mas, 54, 54);
35554 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35555 allocated = mas_allocated(&mas);
35556 height = mas_mt_height(&mas);
35558 mas_store_prealloc(&mas, ptr);
35559 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35562 mas_set_range(&mas, 1, 100);
35563 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL & GFP_NOWAIT) == 0);
35564 allocated = mas_allocated(&mas);
35565 height = mas_mt_height(&mas);
35567 mas_destroy(&mas);
35571 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL) != 0);
35572 allocated = mas_allocated(&mas);
35573 height = mas_mt_height(&mas);
35576 mas_store_prealloc(&mas, ptr);
35577 MT_BUG_ON(mt, mas_allocated(&mas) != 0);
35578 mas_set_range(&mas, 0, 200);
35580 MT_BUG_ON(mt, mas_preallocate(&mas, ptr, GFP_KERNEL & GFP_NOWAIT) == 0);
35581 allocated = mas_allocated(&mas);
35582 height = mas_mt_height(&mas);
35591 MA_STATE(mas, mt, 1200, 2380);
35597 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35598 mas_set(&mas, 1205);
35599 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35607 mas_set_range(&mas, 9, 50006); /* Will expand to 0 - ULONG_MAX */
35608 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35609 mas_set(&mas, 1205);
35610 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35620 mas_set_range(&mas, 0, 12900); /* Spans more than 2 levels */
35622 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35623 mas_set(&mas, 1205);
35624 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35633 mas_set_range(&mas, 0, 300);
35635 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35636 mas_set(&mas, 15);
35637 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35646 mas_set_range(&mas, 0, 12865);
35648 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35649 mas_set(&mas, 15);
35650 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35659 mas_set_range(&mas, 90, 13665);
35661 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35662 mas_set(&mas, 95);
35663 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35672 mas_set_range(&mas, 46805, 49995);
35674 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35675 mas_set(&mas, 46815);
35676 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35688 mas_set_range(&mas, 32395, 49995);
35690 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35691 mas_set(&mas, 46815);
35692 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35703 mas_set_range(&mas, 38875, 43190);
35705 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35706 mas_set(&mas, 38900);
35707 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35716 mas_set(&mas, 47606);
35717 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35718 mas_set(&mas, 47607);
35719 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35720 mas_set(&mas, 47608);
35721 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35722 mas_set(&mas, 47609);
35723 mas_store_gfp(&mas, check_spanning_write, GFP_KERNEL);
35725 mas_ascend(&mas);
35726 MT_BUG_ON(mt, (mas_data_end(&mas)) != mt_slot_count(mas.node) - 1);
35727 mas_set_range(&mas, 11516, 48940);
35728 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35736 mas_set_range(&mas, 43200, 49999);
35738 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35739 mas_set(&mas, 43200);
35740 MT_BUG_ON(mt, mas_walk(&mas) != NULL);
35749 mas_set_range(&mas, 76, 875);
35750 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35760 MA_STATE(mas, mt, 959, 959);
35765 mas_lock(&mas);
35766 mas_walk(&mas);
35767 data_end = mas_data_end(&mas);
35768 mas_set_range(&mas, 959, 963);
35769 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35771 MT_BUG_ON(mt, data_end != mas_data_end(&mas));
35774 mas_set(&mas, 880);
35775 mas_walk(&mas);
35776 data_end = mas_data_end(&mas);
35777 mas_set_range(&mas, 884, 887);
35778 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35782 MT_BUG_ON(mt, data_end != mas_data_end(&mas));
35786 mas_set(&mas, 890);
35787 mas_walk(&mas);
35788 data_end = mas_data_end(&mas);
35789 mas_set_range(&mas, 900, 905);
35790 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35796 MT_BUG_ON(mt, data_end - 2 != mas_data_end(&mas));
35800 mas_set(&mas, 800);
35801 mas_walk(&mas);
35802 data_end = mas_data_end(&mas);
35803 mas_set_range(&mas, 810, 825);
35804 mas_store_gfp(&mas, NULL, GFP_KERNEL);
35810 MT_BUG_ON(mt, data_end - 4 != mas_data_end(&mas));
35812 mas_unlock(&mas);
35976 pr_err("mas->min, mas->max do not match.\n");
35995 static __init void mas_subtree_max_range(struct ma_state *mas)
35997 unsigned long limit = mas->max;
35998 MA_STATE(newmas, mas->tree, 0, 0);
36001 mas_for_each(mas, entry, limit) {
36002 if (mas->last - mas->index >=
36004 newmas = *mas;
36008 *mas = newmas;
36024 MA_STATE(mas, mt, 0, 0);
36035 mas_set(&mas, 0);
36037 mas.max = ULONG_MAX;
36042 mas_dfs_preorder(&mas);
36043 if (mas_is_none(&mas))
36046 type = mte_node_type(mas.node);
36047 if (mas_data_end(&mas) + 1 < mt_slots[type]) {
36048 mas_set(&mas, mas.min);
36053 mas_subtree_max_range(&mas);
36054 step = mas.last - mas.index;
36061 mas.last = mas.index + step;
36062 mas_store_gfp(&mas, xa_mk_value(5),