Lines Matching refs:node
70 pr_err("Hole follows node, expected none!\n");
109 struct drm_mm_node *node, *check, *found;
118 drm_mm_for_each_node(node, mm) {
119 if (node->start != addr) {
120 pr_err("node[%ld] list out of order, expected %llx found %llx\n",
121 n, addr, node->start);
125 if (node->size != size) {
126 pr_err("node[%ld].size incorrect, expected %llx, found %llx\n",
127 n, size, node->size);
131 if (drm_mm_hole_follows(node)) {
132 pr_err("node[%ld] is followed by a hole!\n", n);
138 if (node != check) {
139 pr_err("lookup return wrong node, expected start %llx, found %llx\n",
140 node->start, check->start);
146 pr_err("lookup failed for node %llx + %llx\n",
158 static u64 misalignment(struct drm_mm_node *node, u64 alignment)
165 div64_u64_rem(node->start, alignment, &rem);
169 static bool assert_node(struct drm_mm_node *node, struct drm_mm *mm,
174 if (!drm_mm_node_allocated(node) || node->mm != mm) {
175 pr_err("node not allocated\n");
179 if (node->size != size) {
180 pr_err("node has wrong size, found %llu, expected %llu\n",
181 node->size, size);
185 if (misalignment(node, alignment)) {
186 pr_err("node is misaligned, start %llx rem %llu, expected alignment %llu\n",
187 node->start, misalignment(node, alignment), alignment);
191 if (node->color != color) {
192 pr_err("node has wrong color, found %lu, expected %lu\n",
193 node->color, color);
282 pr_err("failed to reserve node[0] {start=%lld, size=%lld)\n",
291 pr_err("failed to reserve node[1] {start=%lld, size=%lld)\n",
300 static struct drm_mm_node *set_node(struct drm_mm_node *node,
303 node->start = start;
304 node->size = size;
305 return node;
308 static bool expect_reserve_fail(struct drm_mm *mm, struct drm_mm_node *node)
312 err = drm_mm_reserve_node(mm, node);
317 pr_err("impossible reserve succeeded, node %llu + %llu\n",
318 node->start, node->size);
319 drm_mm_remove_node(node);
321 pr_err("impossible reserve failed with wrong error %d [expected %d], node %llu + %llu\n",
322 err, -ENOSPC, node->start, node->size);
376 struct drm_mm_node tmp, *nodes, *node, *next;
417 pr_err("reserved node not allocated! step %d, start %llu\n",
467 node = &nodes[order[(o + m) % count]];
468 drm_mm_remove_node(node);
472 node = &nodes[order[(o + m) % count]];
473 err = drm_mm_reserve_node(&mm, node);
476 m, n, node->start);
490 drm_mm_for_each_node_safe(node, next, &mm)
491 drm_mm_remove_node(node);
526 static bool expect_insert(struct drm_mm *mm, struct drm_mm_node *node,
532 err = drm_mm_insert_node_generic(mm, node,
541 if (!assert_node(node, mm, size, alignment, color)) {
542 drm_mm_remove_node(node);
559 pr_err("impossible insert succeeded, node %llu + %llu\n",
574 struct drm_mm_node *nodes, *node, *next;
599 node = replace ? &tmp : &nodes[n];
600 memset(node, 0, sizeof(*node));
601 if (!expect_insert(&mm, node, size, 0, n, mode)) {
610 pr_err("replaced old-node still allocated! step %d\n",
616 pr_err("replaced node did not inherit parameters, size %llu step %d\n",
622 pr_err("replaced node mismatch location expected [%llx + %llx], found [%llx + %llx]\n",
650 pr_err("%s reinsert node moved, step %d, expected %llx, found %llx\n",
662 node = &nodes[order[(o + m) % count]];
663 drm_mm_remove_node(node);
667 node = &nodes[order[(o + m) % count]];
668 if (!expect_insert(&mm, node, size, 0, n, mode)) {
684 drm_mm_for_each_node_safe(node, next, &mm)
685 drm_mm_remove_node(node);
693 drm_mm_for_each_node_safe(node, next, &mm)
694 drm_mm_remove_node(node);
736 /* Reuse igt_insert to exercise replacement by inserting a dummy node,
737 * then replacing it with the intended node. We want to check that
739 * across to the target node.
763 static bool expect_insert_in_range(struct drm_mm *mm, struct drm_mm_node *node,
770 err = drm_mm_insert_node_in_range(mm, node,
781 if (!assert_node(node, mm, size, alignment, color)) {
782 drm_mm_remove_node(node);
805 pr_err("impossible insert succeeded, node %llx + %llu, range [%llx, %llx]\n",
821 struct drm_mm_node *node;
828 drm_mm_for_each_node(node, mm) {
829 if (node->start < start || node->start + node->size > end) {
830 pr_err("node %d out of range, address [%llx + %llu], range [%llx, %llx]\n",
831 n, node->start, node->start + node->size, start, end);
835 if (node->start != n * size) {
836 pr_err("node %d out of order, expected start %llx, found %llx\n",
837 n, n * size, node->start);
841 if (node->size != size) {
842 pr_err("node %d has wrong size, expected size %llx, found %llx\n",
843 n, size, node->size);
847 if (drm_mm_hole_follows(node) &&
848 drm_mm_hole_node_end(node) < end) {
849 pr_err("node %d is followed by a hole!\n", n);
857 node = __drm_mm_interval_first(mm, 0, start - 1);
858 if (drm_mm_node_allocated(node)) {
859 pr_err("node before start: node=%llx+%llu, start=%llx\n",
860 node->start, node->size, start);
866 node = __drm_mm_interval_first(mm, end, U64_MAX);
867 if (drm_mm_node_allocated(node)) {
868 pr_err("node after end: node=%llx+%llu, end=%llx\n",
869 node->start, node->size, end);
881 struct drm_mm_node *nodes, *node, *next;
936 pr_err("%s reinsert node moved, step %d, expected %llx, found %llx\n",
948 drm_mm_for_each_node_safe(node, next, &mm)
949 drm_mm_remove_node(node);
957 drm_mm_for_each_node_safe(node, next, &mm)
958 drm_mm_remove_node(node);
1053 /* introduce fragmentation by freeing every other node */
1087 struct drm_mm_node *nodes, *node, *next;
1139 drm_mm_for_each_node_safe(node, next, &mm)
1140 drm_mm_remove_node(node);
1145 drm_mm_for_each_node_safe(node, next, &mm)
1146 drm_mm_remove_node(node);
1158 struct drm_mm_node *nodes, *node, *next;
1163 * arbitrary alignments and check that the inserted node
1190 drm_mm_for_each_node_safe(node, next, &mm)
1191 drm_mm_remove_node(node);
1199 drm_mm_for_each_node_safe(node, next, &mm)
1200 drm_mm_remove_node(node);
1210 struct drm_mm_node *node, *next;
1221 node = kzalloc(sizeof(*node), GFP_KERNEL);
1222 if (!node) {
1229 if (!expect_insert(&mm, node,
1242 drm_mm_for_each_node_safe(node, next, &mm) {
1243 drm_mm_remove_node(node);
1244 kfree(node);
1300 struct drm_mm_node node;
1317 if (drm_mm_scan_add_block(scan, &e->node))
1321 if (!drm_mm_scan_remove_block(scan, &e->node))
1331 drm_mm_remove_node(&e->node);
1334 struct drm_mm_node *node;
1336 while ((node = drm_mm_scan_color_evict(scan))) {
1337 e = container_of(node, typeof(*e), node);
1338 drm_mm_remove_node(&e->node);
1358 struct drm_mm_node *node;
1365 drm_mm_scan_add_block(&scan, &e->node);
1368 drm_mm_scan_remove_block(&scan, &e->node);
1373 if (!drm_mm_node_allocated(&e->node)) {
1374 pr_err("node[%d] no longer allocated!\n", n);
1381 drm_mm_for_each_node(node, mm) {
1382 e = container_of(node, typeof(*e), node);
1390 pr_err("node[%d] no longer connected!\n", n);
1395 return assert_continuous(mm, nodes[0].node.size);
1412 if (drm_mm_scan_add_block(&scan, &e->node))
1418 if (!drm_mm_scan_remove_block(&scan, &e->node)) {
1421 e->node.start);
1430 drm_mm_remove_node(&e->node);
1436 err = drm_mm_reserve_node(mm, &e->node);
1438 pr_err("Failed to reinsert node after eviction: start=%llx\n",
1439 e->node.start);
1444 return assert_continuous(mm, nodes[0].node.size);
1502 err = drm_mm_reserve_node(mm, &e->node);
1504 pr_err("Failed to reinsert node after eviction: start=%llx\n",
1505 e->node.start);
1510 if (!assert_continuous(mm, nodes[0].node.size)) {
1525 struct drm_mm_node *node, *next;
1529 /* Here we populate a full drm_mm and then try and insert a new node
1548 err = drm_mm_insert_node(&mm, &nodes[n].node, 1);
1618 drm_mm_for_each_node_safe(node, next, &mm)
1619 drm_mm_remove_node(node);
1638 struct drm_mm_node *node, *next;
1658 err = drm_mm_insert_node(&mm, &nodes[n].node, 1);
1715 drm_mm_for_each_node_safe(node, next, &mm)
1716 drm_mm_remove_node(node);
1725 static unsigned int node_index(const struct drm_mm_node *node)
1727 return div64_u64(node->start, node->size);
1738 struct drm_mm_node *nodes, *node, *next;
1742 /* When allocating top-down, we expect to be returned a node
1744 * the returned node does match the highest available slot.
1787 node = &nodes[order[(o + m) % count]];
1788 drm_mm_remove_node(node);
1789 __set_bit(node_index(node), bitmap);
1795 node = &nodes[order[(o + m) % count]];
1796 if (!expect_insert(&mm, node,
1803 if (drm_mm_hole_follows(node)) {
1805 m, n, node->start);
1810 if (node_index(node) != last) {
1811 pr_err("node %d/%d, size %d, not inserted into upmost hole, expected %d, found %d\n",
1812 m, n, size, last, node_index(node));
1824 drm_mm_for_each_node_safe(node, next, &mm)
1825 drm_mm_remove_node(node);
1832 drm_mm_for_each_node_safe(node, next, &mm)
1833 drm_mm_remove_node(node);
1852 struct drm_mm_node *nodes, *node, *next;
1894 node = &nodes[order[(o + m) % count]];
1895 drm_mm_remove_node(node);
1896 __set_bit(node_index(node), bitmap);
1902 node = &nodes[order[(o + m) % count]];
1903 if (!expect_insert(&mm, node,
1911 if (node_index(node) != first) {
1912 pr_err("node %d/%d not inserted into bottom hole, expected %d, found %d\n",
1913 m, n, first, node_index(node));
1924 drm_mm_for_each_node_safe(node, next, &mm)
1925 drm_mm_remove_node(node);
1932 drm_mm_for_each_node_safe(node, next, &mm)
1933 drm_mm_remove_node(node);
1947 struct drm_mm_node rsvd_lo, rsvd_hi, node;
1957 pr_err("Could not reserve low node\n");
1966 pr_err("Could not reserve low node\n");
1976 memset(&node, 0, sizeof(node));
1977 err = drm_mm_insert_node_generic(&mm, &node, 2, 0, 0, mode);
1979 pr_err("Could not insert the node into the available hole!\n");
1984 drm_mm_remove_node(&node);
2004 static void separate_adjacent_colors(const struct drm_mm_node *node,
2009 if (drm_mm_node_allocated(node) && node->color != color)
2012 node = list_next_entry(node, node_list);
2013 if (drm_mm_node_allocated(node) && node->color != color)
2017 static bool colors_abutt(const struct drm_mm_node *node)
2019 if (!drm_mm_hole_follows(node) &&
2020 drm_mm_node_allocated(list_next_entry(node, node_list))) {
2022 node->color, node->start, node->size,
2023 list_next_entry(node, node_list)->color,
2024 list_next_entry(node, node_list)->start,
2025 list_next_entry(node, node_list)->size);
2037 struct drm_mm_node *node, *nn;
2042 * that when we insert a node we apply any color_adjustment callback.
2051 node = kzalloc(sizeof(*node), GFP_KERNEL);
2052 if (!node) {
2057 if (!expect_insert(&mm, node,
2061 kfree(node);
2066 drm_mm_for_each_node_safe(node, nn, &mm) {
2067 if (node->color != node->size) {
2069 node->size, node->color);
2074 drm_mm_remove_node(node);
2075 kfree(node);
2083 node = kzalloc(sizeof(*node), GFP_KERNEL);
2084 if (!node) {
2089 node->size = 1 + 2*count;
2090 node->color = node->size;
2092 err = drm_mm_reserve_node(&mm, node);
2099 last = node->start + node->size;
2104 node = kzalloc(sizeof(*node), GFP_KERNEL);
2105 if (!node) {
2110 node->start = last;
2111 node->size = n + count;
2112 node->color = node->size;
2114 err = drm_mm_reserve_node(&mm, node);
2121 node->start += n + 1;
2122 rem = misalignment(node, n + count);
2123 node->start += n + count - rem;
2125 err = drm_mm_reserve_node(&mm, node);
2132 last = node->start + node->size;
2136 node = kzalloc(sizeof(*node), GFP_KERNEL);
2137 if (!node) {
2142 if (!expect_insert(&mm, node,
2147 kfree(node);
2152 drm_mm_for_each_node_safe(node, nn, &mm) {
2155 if (node->color != node->size) {
2157 mode->name, node->size, node->color);
2162 if (colors_abutt(node))
2165 div64_u64_rem(node->start, node->size, &rem);
2167 pr_err("%s colored node misaligned, start=%llx expected alignment=%lld [rem=%lld]\n",
2168 mode->name, node->start, node->size, rem);
2172 drm_mm_remove_node(node);
2173 kfree(node);
2181 drm_mm_for_each_node_safe(node, nn, &mm) {
2182 drm_mm_remove_node(node);
2183 kfree(node);
2246 err = drm_mm_reserve_node(mm, &e->node);
2248 pr_err("Failed to reinsert node after eviction: start=%llx\n",
2249 e->node.start);
2266 struct drm_mm_node *node, *next;
2289 if (!expect_insert(&mm, &nodes[n].node,
2348 drm_mm_for_each_node_safe(node, next, &mm)
2349 drm_mm_remove_node(node);
2369 struct drm_mm_node *node, *next;
2390 if (!expect_insert(&mm, &nodes[n].node,
2449 drm_mm_for_each_node_safe(node, next, &mm)
2450 drm_mm_remove_node(node);