Lines Matching refs:nodes
268 struct drm_mm_node nodes[2];
271 /* Create a small drm_mm with a couple of nodes and a few holes, and
277 memset(nodes, 0, sizeof(nodes));
278 nodes[0].start = 512;
279 nodes[0].size = 1024;
280 ret = drm_mm_reserve_node(&mm, &nodes[0]);
283 nodes[0].start, nodes[0].size);
287 nodes[1].size = 1024;
288 nodes[1].start = 4096 - 512 - nodes[1].size;
289 ret = drm_mm_reserve_node(&mm, &nodes[1]);
292 nodes[1].start, nodes[1].size);
376 struct drm_mm_node tmp, *nodes, *node, *next;
383 * the tree and nodes should be intact.
394 nodes = vzalloc(array_size(count, sizeof(*nodes)));
395 if (!nodes)
405 nodes[n].start = order[n] * size;
406 nodes[n].size = size;
408 err = drm_mm_reserve_node(&mm, &nodes[n]);
411 n, nodes[n].start);
416 if (!drm_mm_node_allocated(&nodes[n])) {
418 n, nodes[n].start);
422 if (!expect_reserve_fail(&mm, &nodes[n]))
426 /* After random insertion the nodes should be in order */
438 drm_mm_remove_node(&nodes[order[n]]);
439 err = drm_mm_reserve_node(&mm, &nodes[order[n]]);
442 n, nodes[n].start);
467 node = &nodes[order[(o + m) % count]];
472 node = &nodes[order[(o + m) % count]];
493 vfree(nodes);
574 struct drm_mm_node *nodes, *node, *next;
578 /* Fill a range with lots of nodes, check it doesn't fail too early */
584 nodes = vmalloc(array_size(count, sizeof(*nodes)));
585 if (!nodes)
599 node = replace ? &tmp : &nodes[n];
608 drm_mm_replace_node(&tmp, &nodes[n]);
615 if (!assert_node(&nodes[n], &mm, size, 0, n)) {
621 if (tmp.start != nodes[n].start) {
624 nodes[n].start, nodes[n].size);
630 /* After random insertion the nodes should be in order */
640 u64 addr = nodes[n].start;
642 drm_mm_remove_node(&nodes[n]);
643 if (!expect_insert(&mm, &nodes[n], size, 0, n, mode)) {
649 if (nodes[n].start != addr) {
651 mode->name, n, addr, nodes[n].start);
662 node = &nodes[order[(o + m) % count]];
667 node = &nodes[order[(o + m) % count]];
698 vfree(nodes);
881 struct drm_mm_node *nodes, *node, *next;
894 nodes = vzalloc(array_size(count, sizeof(*nodes)));
895 if (!nodes)
906 if (!expect_insert_in_range(&mm, &nodes[n],
925 u64 addr = nodes[n].start;
927 drm_mm_remove_node(&nodes[n]);
928 if (!expect_insert_in_range(&mm, &nodes[n],
935 if (nodes[n].start != addr) {
937 mode->name, n, addr, nodes[n].start);
960 vfree(nodes);
1038 struct drm_mm_node *nodes,
1046 if (!expect_insert(mm, &nodes[i], size, 0, i,
1056 drm_mm_remove_node(&nodes[i]);
1065 struct drm_mm_node *nodes,
1074 if (!expect_insert(mm, &nodes[i], size, 0, i, mode) != 0) {
1087 struct drm_mm_node *nodes, *node, *next;
1092 /* We need 4 * insert_size nodes to hold intermediate allocated
1093 * drm_mm nodes.
1098 nodes = vzalloc(array_size(insert_size * 4, sizeof(*nodes)));
1099 if (!nodes)
1114 ret = prepare_igt_frag(&mm, nodes, insert_size, mode);
1119 nodes + insert_size, mode);
1124 nodes + insert_size * 2, mode);
1148 vfree(nodes);
1158 struct drm_mm_node *nodes, *node, *next;
1167 nodes = vzalloc(array_size(max_count, sizeof(*nodes)));
1168 if (!nodes)
1179 if (!expect_insert(&mm, &nodes[i],
1202 vfree(nodes);
1305 struct evict_node *nodes,
1315 e = &nodes[order ? order[i] : i];
1343 pr_err("drm_mm_scan_color_evict unexpectedly reported overlapping nodes!\n");
1353 struct evict_node *nodes)
1363 e = &nodes[n];
1371 e = &nodes[n];
1387 e = &nodes[n];
1395 return assert_continuous(mm, nodes[0].node.size);
1400 struct evict_node *nodes)
1410 e = &nodes[n];
1444 return assert_continuous(mm, nodes[0].node.size);
1449 struct evict_node *nodes,
1467 nodes, order, count, false,
1510 if (!assert_continuous(mm, nodes[0].node.size)) {
1524 struct evict_node *nodes;
1530 * by evicting other nodes in a random order. The drm_mm_scan should
1537 nodes = vzalloc(array_size(size, sizeof(*nodes)));
1538 if (!nodes)
1548 err = drm_mm_insert_node(&mm, &nodes[n].node, 1);
1557 if (!evict_nothing(&mm, size, nodes)) {
1561 if (!evict_everything(&mm, size, nodes)) {
1570 nodes, order, size,
1584 nodes, order, size,
1602 nodes, order, size,
1623 vfree(nodes);
1637 struct evict_node *nodes;
1647 nodes = vzalloc(array_size(size, sizeof(*nodes)));
1648 if (!nodes)
1658 err = drm_mm_insert_node(&mm, &nodes[n].node, 1);
1670 nodes, order, size,
1683 nodes, order, size,
1700 nodes, order, size,
1720 vfree(nodes);
1738 struct drm_mm_node *nodes, *node, *next;
1748 nodes = vzalloc(array_size(count, sizeof(*nodes)));
1749 if (!nodes)
1764 if (!expect_insert(&mm, &nodes[n],
1771 if (drm_mm_hole_follows(&nodes[n])) {
1773 n, nodes[n].start, size);
1787 node = &nodes[order[(o + m) % count]];
1795 node = &nodes[order[(o + m) % count]];
1839 vfree(nodes);
1852 struct drm_mm_node *nodes, *node, *next;
1861 nodes = vzalloc(array_size(count, sizeof(*nodes)));
1862 if (!nodes)
1877 if (!expect_insert(&mm, &nodes[n],
1894 node = &nodes[order[(o + m) % count]];
1902 node = &nodes[order[(o + m) % count]];
1939 vfree(nodes);
1971 pr_err("Expected a hole after lo and high nodes!\n");
2044 * any two nodes, and so after each insertion we check that those
2191 struct evict_node *nodes,
2210 nodes, order, count, true,
2265 struct evict_node *nodes;
2272 * allow two nodes to be placed together without an intervening hole
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);
2368 struct evict_node *nodes;
2378 nodes = vzalloc(array_size(total_size, sizeof(*nodes)));
2379 if (!nodes)
2390 if (!expect_insert(&mm, &nodes[n].node,
2402 nodes, order, total_size,
2415 nodes, order, total_size,
2432 nodes, order, total_size,
2454 vfree(nodes);