1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KUnit test for the Kernel Hashtable structures. 4 * 5 * Copyright (C) 2022, Google LLC. 6 * Author: Rae Moar <rmoar@google.com> 7 */ 8 #include <kunit/test.h> 9 10 #include <linux/hashtable.h> 11 12 struct hashtable_test_entry { 13 int key; 14 int data; 15 struct hlist_node node; 16 int visited; 17 }; 18 19 static void hashtable_test_hash_init(struct kunit *test) 20 { 21 /* Test the different ways of initialising a hashtable. */ 22 DEFINE_HASHTABLE(hash1, 2); 23 DECLARE_HASHTABLE(hash2, 3); 24 25 /* When using DECLARE_HASHTABLE, must use hash_init to 26 * initialize the hashtable. 27 */ 28 hash_init(hash2); 29 30 KUNIT_EXPECT_TRUE(test, hash_empty(hash1)); 31 KUNIT_EXPECT_TRUE(test, hash_empty(hash2)); 32 } 33 34 static void hashtable_test_hash_empty(struct kunit *test) 35 { 36 struct hashtable_test_entry a; 37 DEFINE_HASHTABLE(hash, 1); 38 39 KUNIT_EXPECT_TRUE(test, hash_empty(hash)); 40 41 a.key = 1; 42 a.data = 13; 43 hash_add(hash, &a.node, a.key); 44 45 /* Hashtable should no longer be empty. */ 46 KUNIT_EXPECT_FALSE(test, hash_empty(hash)); 47 } 48 49 static void hashtable_test_hash_hashed(struct kunit *test) 50 { 51 struct hashtable_test_entry a, b; 52 DEFINE_HASHTABLE(hash, 4); 53 54 a.key = 1; 55 a.data = 13; 56 hash_add(hash, &a.node, a.key); 57 b.key = 1; 58 b.data = 2; 59 hash_add(hash, &b.node, b.key); 60 61 KUNIT_EXPECT_TRUE(test, hash_hashed(&a.node)); 62 KUNIT_EXPECT_TRUE(test, hash_hashed(&b.node)); 63 } 64 65 static void hashtable_test_hash_add(struct kunit *test) 66 { 67 struct hashtable_test_entry a, b, *x; 68 int bkt; 69 DEFINE_HASHTABLE(hash, 3); 70 71 a.key = 1; 72 a.data = 13; 73 a.visited = 0; 74 hash_add(hash, &a.node, a.key); 75 b.key = 2; 76 b.data = 10; 77 b.visited = 0; 78 hash_add(hash, &b.node, b.key); 79 80 hash_for_each(hash, bkt, x, node) { 81 x->visited++; 82 if (x->key == a.key) 83 KUNIT_EXPECT_EQ(test, x->data, 13); 84 else if (x->key == b.key) 85 KUNIT_EXPECT_EQ(test, x->data, 10); 86 else 87 KUNIT_FAIL(test, "Unexpected key in hashtable."); 88 } 89 90 /* Both entries should have been visited exactly once. */ 91 KUNIT_EXPECT_EQ(test, a.visited, 1); 92 KUNIT_EXPECT_EQ(test, b.visited, 1); 93 } 94 95 static void hashtable_test_hash_del(struct kunit *test) 96 { 97 struct hashtable_test_entry a, b, *x; 98 DEFINE_HASHTABLE(hash, 6); 99 100 a.key = 1; 101 a.data = 13; 102 hash_add(hash, &a.node, a.key); 103 b.key = 2; 104 b.data = 10; 105 b.visited = 0; 106 hash_add(hash, &b.node, b.key); 107 108 hash_del(&b.node); 109 hash_for_each_possible(hash, x, node, b.key) { 110 x->visited++; 111 KUNIT_EXPECT_NE(test, x->key, b.key); 112 } 113 114 /* The deleted entry should not have been visited. */ 115 KUNIT_EXPECT_EQ(test, b.visited, 0); 116 117 hash_del(&a.node); 118 119 /* The hashtable should be empty. */ 120 KUNIT_EXPECT_TRUE(test, hash_empty(hash)); 121 } 122 123 static void hashtable_test_hash_for_each(struct kunit *test) 124 { 125 struct hashtable_test_entry entries[3]; 126 struct hashtable_test_entry *x; 127 int bkt, i, j, count; 128 DEFINE_HASHTABLE(hash, 3); 129 130 /* Add three entries to the hashtable. */ 131 for (i = 0; i < 3; i++) { 132 entries[i].key = i; 133 entries[i].data = i + 10; 134 entries[i].visited = 0; 135 hash_add(hash, &entries[i].node, entries[i].key); 136 } 137 138 count = 0; 139 hash_for_each(hash, bkt, x, node) { 140 x->visited += 1; 141 KUNIT_ASSERT_GE_MSG(test, x->key, 0, "Unexpected key in hashtable."); 142 KUNIT_ASSERT_LT_MSG(test, x->key, 3, "Unexpected key in hashtable."); 143 count++; 144 } 145 146 /* Should have visited each entry exactly once. */ 147 KUNIT_EXPECT_EQ(test, count, 3); 148 for (j = 0; j < 3; j++) 149 KUNIT_EXPECT_EQ(test, entries[j].visited, 1); 150 } 151 152 static void hashtable_test_hash_for_each_safe(struct kunit *test) 153 { 154 struct hashtable_test_entry entries[3]; 155 struct hashtable_test_entry *x; 156 struct hlist_node *tmp; 157 int bkt, i, j, count; 158 DEFINE_HASHTABLE(hash, 3); 159 160 /* Add three entries to the hashtable. */ 161 for (i = 0; i < 3; i++) { 162 entries[i].key = i; 163 entries[i].data = i + 10; 164 entries[i].visited = 0; 165 hash_add(hash, &entries[i].node, entries[i].key); 166 } 167 168 count = 0; 169 hash_for_each_safe(hash, bkt, tmp, x, node) { 170 x->visited += 1; 171 KUNIT_ASSERT_GE_MSG(test, x->key, 0, "Unexpected key in hashtable."); 172 KUNIT_ASSERT_LT_MSG(test, x->key, 3, "Unexpected key in hashtable."); 173 count++; 174 175 /* Delete entry during loop. */ 176 hash_del(&x->node); 177 } 178 179 /* Should have visited each entry exactly once. */ 180 KUNIT_EXPECT_EQ(test, count, 3); 181 for (j = 0; j < 3; j++) 182 KUNIT_EXPECT_EQ(test, entries[j].visited, 1); 183 } 184 185 static void hashtable_test_hash_for_each_possible(struct kunit *test) 186 { 187 struct hashtable_test_entry entries[4]; 188 struct hashtable_test_entry *x, *y; 189 int buckets[2]; 190 int bkt, i, j, count; 191 DEFINE_HASHTABLE(hash, 5); 192 193 /* Add three entries with key = 0 to the hashtable. */ 194 for (i = 0; i < 3; i++) { 195 entries[i].key = 0; 196 entries[i].data = i; 197 entries[i].visited = 0; 198 hash_add(hash, &entries[i].node, entries[i].key); 199 } 200 201 /* Add an entry with key = 1. */ 202 entries[3].key = 1; 203 entries[3].data = 3; 204 entries[3].visited = 0; 205 hash_add(hash, &entries[3].node, entries[3].key); 206 207 count = 0; 208 hash_for_each_possible(hash, x, node, 0) { 209 x->visited += 1; 210 KUNIT_ASSERT_GE_MSG(test, x->data, 0, "Unexpected data in hashtable."); 211 KUNIT_ASSERT_LT_MSG(test, x->data, 4, "Unexpected data in hashtable."); 212 count++; 213 } 214 215 /* Should have visited each entry with key = 0 exactly once. */ 216 for (j = 0; j < 3; j++) 217 KUNIT_EXPECT_EQ(test, entries[j].visited, 1); 218 219 /* Save the buckets for the different keys. */ 220 hash_for_each(hash, bkt, y, node) { 221 KUNIT_ASSERT_GE_MSG(test, y->key, 0, "Unexpected key in hashtable."); 222 KUNIT_ASSERT_LE_MSG(test, y->key, 1, "Unexpected key in hashtable."); 223 buckets[y->key] = bkt; 224 } 225 226 /* If entry with key = 1 is in the same bucket as the entries with 227 * key = 0, check it was visited. Otherwise ensure that only three 228 * entries were visited. 229 */ 230 if (buckets[0] == buckets[1]) { 231 KUNIT_EXPECT_EQ(test, count, 4); 232 KUNIT_EXPECT_EQ(test, entries[3].visited, 1); 233 } else { 234 KUNIT_EXPECT_EQ(test, count, 3); 235 KUNIT_EXPECT_EQ(test, entries[3].visited, 0); 236 } 237 } 238 239 static void hashtable_test_hash_for_each_possible_safe(struct kunit *test) 240 { 241 struct hashtable_test_entry entries[4]; 242 struct hashtable_test_entry *x, *y; 243 struct hlist_node *tmp; 244 int buckets[2]; 245 int bkt, i, j, count; 246 DEFINE_HASHTABLE(hash, 5); 247 248 /* Add three entries with key = 0 to the hashtable. */ 249 for (i = 0; i < 3; i++) { 250 entries[i].key = 0; 251 entries[i].data = i; 252 entries[i].visited = 0; 253 hash_add(hash, &entries[i].node, entries[i].key); 254 } 255 256 /* Add an entry with key = 1. */ 257 entries[3].key = 1; 258 entries[3].data = 3; 259 entries[3].visited = 0; 260 hash_add(hash, &entries[3].node, entries[3].key); 261 262 count = 0; 263 hash_for_each_possible_safe(hash, x, tmp, node, 0) { 264 x->visited += 1; 265 KUNIT_ASSERT_GE_MSG(test, x->data, 0, "Unexpected data in hashtable."); 266 KUNIT_ASSERT_LT_MSG(test, x->data, 4, "Unexpected data in hashtable."); 267 count++; 268 269 /* Delete entry during loop. */ 270 hash_del(&x->node); 271 } 272 273 /* Should have visited each entry with key = 0 exactly once. */ 274 for (j = 0; j < 3; j++) 275 KUNIT_EXPECT_EQ(test, entries[j].visited, 1); 276 277 /* Save the buckets for the different keys. */ 278 hash_for_each(hash, bkt, y, node) { 279 KUNIT_ASSERT_GE_MSG(test, y->key, 0, "Unexpected key in hashtable."); 280 KUNIT_ASSERT_LE_MSG(test, y->key, 1, "Unexpected key in hashtable."); 281 buckets[y->key] = bkt; 282 } 283 284 /* If entry with key = 1 is in the same bucket as the entries with 285 * key = 0, check it was visited. Otherwise ensure that only three 286 * entries were visited. 287 */ 288 if (buckets[0] == buckets[1]) { 289 KUNIT_EXPECT_EQ(test, count, 4); 290 KUNIT_EXPECT_EQ(test, entries[3].visited, 1); 291 } else { 292 KUNIT_EXPECT_EQ(test, count, 3); 293 KUNIT_EXPECT_EQ(test, entries[3].visited, 0); 294 } 295 } 296 297 static struct kunit_case hashtable_test_cases[] = { 298 KUNIT_CASE(hashtable_test_hash_init), 299 KUNIT_CASE(hashtable_test_hash_empty), 300 KUNIT_CASE(hashtable_test_hash_hashed), 301 KUNIT_CASE(hashtable_test_hash_add), 302 KUNIT_CASE(hashtable_test_hash_del), 303 KUNIT_CASE(hashtable_test_hash_for_each), 304 KUNIT_CASE(hashtable_test_hash_for_each_safe), 305 KUNIT_CASE(hashtable_test_hash_for_each_possible), 306 KUNIT_CASE(hashtable_test_hash_for_each_possible_safe), 307 {}, 308 }; 309 310 static struct kunit_suite hashtable_test_module = { 311 .name = "hashtable", 312 .test_cases = hashtable_test_cases, 313 }; 314 315 kunit_test_suites(&hashtable_test_module); 316 317 MODULE_DESCRIPTION("KUnit test for the Kernel Hashtable structures"); 318 MODULE_LICENSE("GPL"); 319