#define BUFFER_NUM 5
#define BUFFER_MIN_SIZE (PAGE_SIZE / 8)
-static int binder_alloc_test_failures;
+#define FREESEQ_BUFLEN ((3 * BUFFER_NUM) + 1)
+
+#define ALIGN_TYPE_STRLEN (12)
+
+#define ALIGNMENTS_BUFLEN (((ALIGN_TYPE_STRLEN + 6) * BUFFER_NUM) + 1)
+
+#define PRINT_ALL_CASES (0)
+
+/* 5^5 alignment combinations * 2 places to share pages * 5! free sequences */
+#define TOTAL_EXHAUSTIVE_CASES (3125 * 2 * 120)
/**
* enum buf_end_align_type - Page alignment of a buffer
LOOP_END,
};
-static void pr_err_size_seq(struct kunit *test, size_t *sizes, int *seq)
+static const char *const buf_end_align_type_strs[LOOP_END] = {
+ [SAME_PAGE_UNALIGNED] = "SP_UNALIGNED",
+ [SAME_PAGE_ALIGNED] = " SP_ALIGNED ",
+ [NEXT_PAGE_UNALIGNED] = "NP_UNALIGNED",
+ [NEXT_PAGE_ALIGNED] = " NP_ALIGNED ",
+ [NEXT_NEXT_UNALIGNED] = "NN_UNALIGNED",
+};
+
+struct binder_alloc_test_case_info {
+ size_t *buffer_sizes;
+ int *free_sequence;
+ char alignments[ALIGNMENTS_BUFLEN];
+ bool front_pages;
+};
+
+static void stringify_free_seq(struct kunit *test, int *seq, char *buf,
+ size_t buf_len)
{
+ size_t bytes = 0;
int i;
- kunit_err(test, "alloc sizes: ");
- for (i = 0; i < BUFFER_NUM; i++)
- pr_cont("[%zu]", sizes[i]);
- pr_cont("\n");
- kunit_err(test, "free seq: ");
- for (i = 0; i < BUFFER_NUM; i++)
- pr_cont("[%d]", seq[i]);
- pr_cont("\n");
+ for (i = 0; i < BUFFER_NUM; i++) {
+ bytes += snprintf(buf + bytes, buf_len - bytes, "[%d]", seq[i]);
+ if (bytes >= buf_len)
+ break;
+ }
+ KUNIT_EXPECT_LT(test, bytes, buf_len);
+}
+
+static void stringify_alignments(struct kunit *test, int *alignments,
+ char *buf, size_t buf_len)
+{
+ size_t bytes = 0;
+ int i;
+
+ for (i = 0; i < BUFFER_NUM; i++) {
+ bytes += snprintf(buf + bytes, buf_len - bytes, "[ %d:%s ]", i,
+ buf_end_align_type_strs[alignments[i]]);
+ if (bytes >= buf_len)
+ break;
+ }
+
+ KUNIT_EXPECT_LT(test, bytes, buf_len);
}
static bool check_buffer_pages_allocated(struct kunit *test,
return true;
}
-static void binder_alloc_test_alloc_buf(struct kunit *test,
- struct binder_alloc *alloc,
- struct binder_buffer *buffers[],
- size_t *sizes, int *seq)
+static unsigned long binder_alloc_test_alloc_buf(struct kunit *test,
+ struct binder_alloc *alloc,
+ struct binder_buffer *buffers[],
+ size_t *sizes, int *seq)
{
+ unsigned long failures = 0;
int i;
for (i = 0; i < BUFFER_NUM; i++) {
buffers[i] = binder_alloc_new_buf(alloc, sizes[i], 0, 0, 0);
if (IS_ERR(buffers[i]) ||
- !check_buffer_pages_allocated(test, alloc, buffers[i], sizes[i])) {
- pr_err_size_seq(test, sizes, seq);
- binder_alloc_test_failures++;
- }
+ !check_buffer_pages_allocated(test, alloc, buffers[i], sizes[i]))
+ failures++;
}
+
+ return failures;
}
-static void binder_alloc_test_free_buf(struct kunit *test,
- struct binder_alloc *alloc,
- struct binder_buffer *buffers[],
- size_t *sizes, int *seq, size_t end)
+static unsigned long binder_alloc_test_free_buf(struct kunit *test,
+ struct binder_alloc *alloc,
+ struct binder_buffer *buffers[],
+ size_t *sizes, int *seq, size_t end)
{
+ unsigned long failures = 0;
int i;
for (i = 0; i < BUFFER_NUM; i++)
for (i = 0; i <= (end - 1) / PAGE_SIZE; i++) {
if (list_empty(page_to_lru(alloc->pages[i]))) {
- pr_err_size_seq(test, sizes, seq);
kunit_err(test, "expect lru but is %s at page index %d\n",
alloc->pages[i] ? "alloc" : "free", i);
- binder_alloc_test_failures++;
+ failures++;
}
}
+
+ return failures;
}
-static void binder_alloc_test_free_page(struct kunit *test,
- struct binder_alloc *alloc)
+static unsigned long binder_alloc_test_free_page(struct kunit *test,
+ struct binder_alloc *alloc)
{
+ unsigned long failures = 0;
unsigned long count;
int i;
kunit_err(test, "expect free but is %s at page index %d\n",
list_empty(page_to_lru(alloc->pages[i])) ?
"alloc" : "lru", i);
- binder_alloc_test_failures++;
+ failures++;
}
}
+
+ return failures;
}
-static void binder_alloc_test_alloc_free(struct kunit *test,
+/* Executes one full test run for the given test case. */
+static bool binder_alloc_test_alloc_free(struct kunit *test,
struct binder_alloc *alloc,
- size_t *sizes, int *seq, size_t end)
+ struct binder_alloc_test_case_info *tc,
+ size_t end)
{
+ unsigned long pages = PAGE_ALIGN(end) / PAGE_SIZE;
struct binder_buffer *buffers[BUFFER_NUM];
-
- binder_alloc_test_alloc_buf(test, alloc, buffers, sizes, seq);
- binder_alloc_test_free_buf(test, alloc, buffers, sizes, seq, end);
+ unsigned long failures;
+ bool failed = false;
+
+ failures = binder_alloc_test_alloc_buf(test, alloc, buffers,
+ tc->buffer_sizes,
+ tc->free_sequence);
+ failed = failed || failures;
+ KUNIT_EXPECT_EQ_MSG(test, failures, 0,
+ "Initial allocation failed: %lu/%u buffers with errors",
+ failures, BUFFER_NUM);
+
+ failures = binder_alloc_test_free_buf(test, alloc, buffers,
+ tc->buffer_sizes,
+ tc->free_sequence, end);
+ failed = failed || failures;
+ KUNIT_EXPECT_EQ_MSG(test, failures, 0,
+ "Initial buffers not freed correctly: %lu/%lu pages not on lru list",
+ failures, pages);
/* Allocate from lru. */
- binder_alloc_test_alloc_buf(test, alloc, buffers, sizes, seq);
- if (list_lru_count(alloc->freelist))
- kunit_err(test, "lru list should be empty but is not\n");
-
- binder_alloc_test_free_buf(test, alloc, buffers, sizes, seq, end);
- binder_alloc_test_free_page(test, alloc);
+ failures = binder_alloc_test_alloc_buf(test, alloc, buffers,
+ tc->buffer_sizes,
+ tc->free_sequence);
+ failed = failed || failures;
+ KUNIT_EXPECT_EQ_MSG(test, failures, 0,
+ "Reallocation failed: %lu/%u buffers with errors",
+ failures, BUFFER_NUM);
+
+ failures = list_lru_count(alloc->freelist);
+ failed = failed || failures;
+ KUNIT_EXPECT_EQ_MSG(test, failures, 0,
+ "lru list should be empty after reallocation but still has %lu pages",
+ failures);
+
+ failures = binder_alloc_test_free_buf(test, alloc, buffers,
+ tc->buffer_sizes,
+ tc->free_sequence, end);
+ failed = failed || failures;
+ KUNIT_EXPECT_EQ_MSG(test, failures, 0,
+ "Reallocated buffers not freed correctly: %lu/%lu pages not on lru list",
+ failures, pages);
+
+ failures = binder_alloc_test_free_page(test, alloc);
+ failed = failed || failures;
+ KUNIT_EXPECT_EQ_MSG(test, failures, 0,
+ "Failed to clean up allocated pages: %lu/%lu pages still installed",
+ failures, (alloc->buffer_size / PAGE_SIZE));
+
+ return failed;
}
static bool is_dup(int *seq, int index, int val)
/* Generate BUFFER_NUM factorial free orders. */
static void permute_frees(struct kunit *test, struct binder_alloc *alloc,
- size_t *sizes, int *seq, int index, size_t end)
+ struct binder_alloc_test_case_info *tc,
+ unsigned long *runs, unsigned long *failures,
+ int index, size_t end)
{
+ bool case_failed;
int i;
if (index == BUFFER_NUM) {
- binder_alloc_test_alloc_free(test, alloc, sizes, seq, end);
+ char freeseq_buf[FREESEQ_BUFLEN];
+
+ case_failed = binder_alloc_test_alloc_free(test, alloc, tc, end);
+ *runs += 1;
+ *failures += case_failed;
+
+ if (case_failed || PRINT_ALL_CASES) {
+ stringify_free_seq(test, tc->free_sequence, freeseq_buf,
+ FREESEQ_BUFLEN);
+ kunit_err(test, "case %lu: [%s] | %s - %s - %s", *runs,
+ case_failed ? "FAILED" : "PASSED",
+ tc->front_pages ? "front" : "back ",
+ tc->alignments, freeseq_buf);
+ }
+
return;
}
for (i = 0; i < BUFFER_NUM; i++) {
- if (is_dup(seq, index, i))
+ if (is_dup(tc->free_sequence, index, i))
continue;
- seq[index] = i;
- permute_frees(test, alloc, sizes, seq, index + 1, end);
+ tc->free_sequence[index] = i;
+ permute_frees(test, alloc, tc, runs, failures, index + 1, end);
}
}
-static void gen_buf_sizes(struct kunit *test, struct binder_alloc *alloc,
- size_t *end_offset)
+static void gen_buf_sizes(struct kunit *test,
+ struct binder_alloc *alloc,
+ struct binder_alloc_test_case_info *tc,
+ size_t *end_offset, unsigned long *runs,
+ unsigned long *failures)
{
size_t last_offset, offset = 0;
size_t front_sizes[BUFFER_NUM];
int seq[BUFFER_NUM] = {0};
int i;
+ tc->free_sequence = seq;
for (i = 0; i < BUFFER_NUM; i++) {
last_offset = offset;
offset = end_offset[i];
front_sizes[i] = offset - last_offset;
back_sizes[BUFFER_NUM - i - 1] = front_sizes[i];
}
+ back_sizes[0] += alloc->buffer_size - end_offset[BUFFER_NUM - 1];
+
/*
* Buffers share the first or last few pages.
* Only BUFFER_NUM - 1 buffer sizes are adjustable since
* we need one giant buffer before getting to the last page.
*/
- back_sizes[0] += alloc->buffer_size - end_offset[BUFFER_NUM - 1];
- permute_frees(test, alloc, front_sizes, seq, 0,
+ tc->front_pages = true;
+ tc->buffer_sizes = front_sizes;
+ permute_frees(test, alloc, tc, runs, failures, 0,
end_offset[BUFFER_NUM - 1]);
- permute_frees(test, alloc, back_sizes, seq, 0, alloc->buffer_size);
+
+ tc->front_pages = false;
+ tc->buffer_sizes = back_sizes;
+ permute_frees(test, alloc, tc, runs, failures, 0, alloc->buffer_size);
}
static void gen_buf_offsets(struct kunit *test, struct binder_alloc *alloc,
- size_t *end_offset, int index)
+ size_t *end_offset, int *alignments,
+ unsigned long *runs, unsigned long *failures,
+ int index)
{
size_t end, prev;
int align;
if (index == BUFFER_NUM) {
- gen_buf_sizes(test, alloc, end_offset);
+ struct binder_alloc_test_case_info tc = {0};
+
+ stringify_alignments(test, alignments, tc.alignments,
+ ALIGNMENTS_BUFLEN);
+
+ gen_buf_sizes(test, alloc, &tc, end_offset, runs, failures);
return;
}
prev = index == 0 ? 0 : end_offset[index - 1];
else
end += BUFFER_MIN_SIZE;
end_offset[index] = end;
- gen_buf_offsets(test, alloc, end_offset, index + 1);
+ alignments[index] = align;
+ gen_buf_offsets(test, alloc, end_offset, alignments, runs,
+ failures, index + 1);
}
}
{
struct binder_alloc_test *priv = test->priv;
size_t end_offset[BUFFER_NUM];
+ int alignments[BUFFER_NUM];
+ unsigned long failures = 0;
+ unsigned long runs = 0;
- gen_buf_offsets(test, &priv->alloc, end_offset, 0);
+ gen_buf_offsets(test, &priv->alloc, end_offset, alignments, &runs,
+ &failures, 0);
- KUNIT_EXPECT_EQ(test, binder_alloc_test_failures, 0);
+ KUNIT_EXPECT_EQ(test, runs, TOTAL_EXHAUSTIVE_CASES);
+ KUNIT_EXPECT_EQ(test, failures, 0);
}
/* ===== End test cases ===== */
projects / thirdparty / kernel / stable.git / commitdiff
