Lines Matching defs:nodes
272 struct drm_mm_node nodes[2];
275 /* Create a small drm_mm with a couple of nodes and a few holes, and
281 memset(nodes, 0, sizeof(nodes));
282 nodes[0].start = 512;
283 nodes[0].size = 1024;
284 ret = drm_mm_reserve_node(&mm, &nodes[0]);
287 nodes[0].start, nodes[0].size);
291 nodes[1].size = 1024;
292 nodes[1].start = 4096 - 512 - nodes[1].size;
293 ret = drm_mm_reserve_node(&mm, &nodes[1]);
296 nodes[1].start, nodes[1].size);
380 struct drm_mm_node tmp, *nodes, *node, *next;
387 * the tree and nodes should be intact.
398 nodes = vzalloc(array_size(count, sizeof(*nodes)));
399 if (!nodes)
409 nodes[n].start = order[n] * size;
410 nodes[n].size = size;
412 err = drm_mm_reserve_node(&mm, &nodes[n]);
415 n, nodes[n].start);
420 if (!drm_mm_node_allocated(&nodes[n])) {
422 n, nodes[n].start);
426 if (!expect_reserve_fail(&mm, &nodes[n]))
430 /* After random insertion the nodes should be in order */
442 drm_mm_remove_node(&nodes[order[n]]);
443 err = drm_mm_reserve_node(&mm, &nodes[order[n]]);
446 n, nodes[n].start);
471 node = &nodes[order[(o + m) % count]];
476 node = &nodes[order[(o + m) % count]];
497 vfree(nodes);
578 struct drm_mm_node *nodes, *node, *next;
582 /* Fill a range with lots of nodes, check it doesn't fail too early */
588 nodes = vmalloc(array_size(count, sizeof(*nodes)));
589 if (!nodes)
603 node = replace ? &tmp : &nodes[n];
612 drm_mm_replace_node(&tmp, &nodes[n]);
619 if (!assert_node(&nodes[n], &mm, size, 0, n)) {
625 if (tmp.start != nodes[n].start) {
628 nodes[n].start, nodes[n].size);
634 /* After random insertion the nodes should be in order */
644 u64 addr = nodes[n].start;
646 drm_mm_remove_node(&nodes[n]);
647 if (!expect_insert(&mm, &nodes[n], size, 0, n, mode)) {
653 if (nodes[n].start != addr) {
655 mode->name, n, addr, nodes[n].start);
666 node = &nodes[order[(o + m) % count]];
671 node = &nodes[order[(o + m) % count]];
702 vfree(nodes);
885 struct drm_mm_node *nodes, *node, *next;
898 nodes = vzalloc(array_size(count, sizeof(*nodes)));
899 if (!nodes)
910 if (!expect_insert_in_range(&mm, &nodes[n],
929 u64 addr = nodes[n].start;
931 drm_mm_remove_node(&nodes[n]);
932 if (!expect_insert_in_range(&mm, &nodes[n],
939 if (nodes[n].start != addr) {
941 mode->name, n, addr, nodes[n].start);
964 vfree(nodes);
1046 struct drm_mm_node *nodes, *node, *next;
1055 nodes = vzalloc(array_size(max_count, sizeof(*nodes)));
1056 if (!nodes)
1067 if (!expect_insert(&mm, &nodes[i],
1090 vfree(nodes);
1193 struct evict_node *nodes,
1203 e = &nodes[order ? order[i] : i];
1231 pr_err("drm_mm_scan_color_evict unexpectedly reported overlapping nodes!\n");
1241 struct evict_node *nodes)
1251 e = &nodes[n];
1259 e = &nodes[n];
1275 e = &nodes[n];
1283 return assert_continuous(mm, nodes[0].node.size);
1288 struct evict_node *nodes)
1298 e = &nodes[n];
1332 return assert_continuous(mm, nodes[0].node.size);
1337 struct evict_node *nodes,
1355 nodes, order, count, false,
1398 if (!assert_continuous(mm, nodes[0].node.size)) {
1412 struct evict_node *nodes;
1418 * by evicting other nodes in a random order. The drm_mm_scan should
1425 nodes = vzalloc(array_size(size, sizeof(*nodes)));
1426 if (!nodes)
1436 err = drm_mm_insert_node(&mm, &nodes[n].node, 1);
1445 if (!evict_nothing(&mm, size, nodes)) {
1449 if (!evict_everything(&mm, size, nodes)) {
1458 nodes, order, size,
1472 nodes, order, size,
1490 nodes, order, size,
1511 vfree(nodes);
1525 struct evict_node *nodes;
1535 nodes = vzalloc(array_size(size, sizeof(*nodes)));
1536 if (!nodes)
1546 err = drm_mm_insert_node(&mm, &nodes[n].node, 1);
1558 nodes, order, size,
1571 nodes, order, size,
1588 nodes, order, size,
1608 vfree(nodes);
1626 struct drm_mm_node *nodes, *node, *next;
1636 nodes = vzalloc(array_size(count, sizeof(*nodes)));
1637 if (!nodes)
1652 if (!expect_insert(&mm, &nodes[n],
1659 if (drm_mm_hole_follows(&nodes[n])) {
1661 n, nodes[n].start, size);
1675 node = &nodes[order[(o + m) % count]];
1683 node = &nodes[order[(o + m) % count]];
1727 vfree(nodes);
1740 struct drm_mm_node *nodes, *node, *next;
1749 nodes = vzalloc(array_size(count, sizeof(*nodes)));
1750 if (!nodes)
1765 if (!expect_insert(&mm, &nodes[n],
1782 node = &nodes[order[(o + m) % count]];
1790 node = &nodes[order[(o + m) % count]];
1827 vfree(nodes);
1859 pr_err("Expected a hole after lo and high nodes!\n");
1943 * any two nodes, and so after each insertion we check that those
2090 struct evict_node *nodes,
2109 nodes, order, count, true,
2164 struct evict_node *nodes;
2171 * allow two nodes to be placed together without an intervening hole
2176 nodes = vzalloc(array_size(total_size, sizeof(*nodes)));
2177 if (!nodes)
2188 if (!expect_insert(&mm, &nodes[n].node,
2200 nodes, order, total_size,
2213 nodes, order, total_size,
2230 nodes, order, total_size,
2252 vfree(nodes);
2267 struct evict_node *nodes;
2277 nodes = vzalloc(array_size(total_size, sizeof(*nodes)));
2278 if (!nodes)
2289 if (!expect_insert(&mm, &nodes[n].node,
2301 nodes, order, total_size,
2314 nodes, order, total_size,
2331 nodes, order, total_size,
2353 vfree(nodes);
Indexes created Wed Oct 01 15:09:59 GMT 2025