Imported mint and idr source for userspace
[minor-tree:mint.git] / tests / mint_tests.c
1 /* mint_tests.c - some library test functions
2  *
3  * Copyright (C) 2004 Yann Droneaud <ydroneaud@meuh.org>.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2, or (at your option)
8  * any later version.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  *
19  */
20
21 #include <stdio.h>
22
23 #include <linux/mint.h>
24
25 #include "mint_tests.h"
26
27 void
28 print_tree(struct mint **tree)
29 {
30   printf(" tree = %p", *tree);
31     
32   if (MINT_EMPTY(tree))
33     printf(" EMPTY");
34
35   printf(" used: %d, free %d", 
36           MINT_COUNT(tree), MINT_FREE(tree));
37
38   if (!MINT_EMPTY(tree))
39     printf(" min: %u, max %u", MINT_MIN(tree), MINT_MAX(tree));
40
41   printf("\n");
42
43 }
44
45 void 
46 node_dump(const char * function, int line, 
47           const char *name, struct mint *node)
48 {
49   int i;
50
51   fflush(stdout);
52
53   printf("%s():%d  %s: %p  ", function, line, name, node);
54
55   if (node == NULL)
56     return;
57
58   printf("level: %d prefix: 0x%04x (%d)", 
59          node->mint_level,
60          node->mint_prefix, node->mint_prefix << MINT_BIT_SHIFT);
61
62   printf(" tree count: %d min: %d max: %d\n",
63          node->mint_tree_count,
64          node->mint_min,
65          node->mint_max );
66
67   printf("%s():%d  %s: %p  ", function, line, name, node);
68
69   printf("count: %d allocated: 0x%08x free: 0x%08x\n", 
70          node->mint_count,
71          node->mint_alloc_bitmap,
72          node->mint_free_bitmap);
73
74   printf("%s():%d  %s: %p  ", function, line, name, node);
75
76   for(i = 0; i < 32; i++)
77     {
78       if (node->mint_alloc_bitmap & (1 << i))
79         if (node->mint_level == 3) {
80           printf(" %u", (node->mint_prefix << MINT_BIT_SHIFT) | i);
81         } else {
82           printf(" %p", node->mint_ptr[i]);
83         }
84       else
85         printf(" ()");
86     }
87
88   printf("\n");
89
90   fflush(stdout);
91 }
92
93 int
94 node_check(struct mint *node)
95 {
96   int i;
97
98   int err = 0;
99
100   __u16 prefix;
101
102   int first;
103   int last;
104
105   int offset;
106
107   if (node == NULL) {
108     printf("FATAL, node == NULL , leaving\n");
109     return 1;
110   }
111
112   /* valid levels are [0..3] */
113   if (node->mint_level >= MINT_MAX_DEEP) {
114     printf("incorrect level\n");
115     err++;
116   }
117
118   /* only 32 slot per node */
119   if (node->mint_count > 32) {
120     printf("incorrect mint_count\n");
121     err ++;
122   }
123
124   /* tree counts are { 1048576, 32768, 1024, 32 } */
125   if (node->mint_tree_count > (unsigned) (1 << ((MINT_MAX_DEEP - node->mint_level) * MINT_BIT_SHIFT))) {
126     printf("incorrect mint_tree_count\n");
127     err ++;
128   }
129
130   if (node->mint_min > node->mint_max) {
131     printf("min > max\n");
132     err++;
133   }
134
135   if (node->mint_level != 3) {
136
137     /* only level 3 node can hold less than 2 slots */
138
139     if (node->mint_tree_count < 2) {
140         printf("tree count < 2\n");
141         err ++;
142     }
143     if (node->mint_count < 2) {
144         printf("count < 2\n");
145         err ++;
146     }
147   } else {
148     if (node->mint_count < 1) {
149         printf("count < 1\n");
150         err ++;
151     }
152
153     if (node->mint_tree_count != node->mint_count) {
154       printf("tree count != mint_count\n");
155       err ++;
156     }
157
158     if (node->mint_count == 1) {
159       if (node->mint_min != node->mint_max) {
160         printf("mint_min != mint_max\n");
161         err ++;
162       }
163     } else {
164       if (node->mint_min == node->mint_max) {
165         printf("mint_min == mint_max\n");
166         err ++;
167       }
168     }
169   } 
170
171   /* check bitmaps */
172   if (node->mint_count == 32) {
173     if (node->mint_alloc_bitmap != ~0UL) {
174       printf("mint_alloc_bitmap mismatch\n");
175       err ++;
176     }
177     if (node->mint_level == 3 && node->mint_free_bitmap != 0) {
178       printf("mint_free_bitmap mismatch at level 3\n");
179       err ++;
180     }
181   }
182
183   /* build prefix from min and max values */
184   
185   offset = MINORBITS - MINT_BIT_SHIFT - node->mint_level * MINT_BIT_SHIFT;
186
187   prefix = (node->mint_min >> MINT_BIT_SHIFT);
188   prefix &= ~ ((1 << offset) - 1); 
189   if (node->mint_prefix != prefix) {
190     printf("min: bad prefix: 0x%04x (%u) (offset = %d)\n", prefix, prefix << MINT_BIT_SHIFT, offset);
191     err ++;
192   }
193
194   prefix = (node->mint_max >> MINT_BIT_SHIFT);
195   prefix &= ~ ((1 << offset) - 1); 
196   if (node->mint_prefix != prefix) {
197     printf("max: bad prefix: 0x%04x (%u) (offset = %d)\n", prefix, prefix << MINT_BIT_SHIFT, offset);
198     err ++;
199   }
200
201   /* check pointer list */
202   first = 32;
203   last = 0;
204   
205   for(i = 0; i < 32; i++) {
206     if (node->mint_alloc_bitmap & (1 << i)) {
207       if (i < first)
208         first = i;
209           
210       if (i > last)
211         last = i;
212
213       if (node->mint_level != 3 && node->mint_ptr[i] == NULL) {
214         printf("Allocated pointer %d == NULL\n", i);
215         err ++;
216       }
217     } else {
218       if (node->mint_ptr[i] != NULL) {
219         printf("Unallocated pointer %d not null\n", i);
220         err ++;
221       }
222           
223       if (!(node->mint_free_bitmap & (1 << i))) {
224         printf("pointer %d not free\n", i);
225         err ++;
226       }
227           
228     }
229   }
230
231   if (node->mint_level != 3) {
232
233     /* check min and max value against lower nodes values */
234
235     if (node->mint_min != node->mint_ptr[first]->mint_min) {
236       printf("Min mismatch\n");
237       err ++;
238     }
239
240     if (node->mint_max != node->mint_ptr[last]->mint_max) {
241       printf("Max mismatch\n");
242       err ++;
243     }
244   } else {
245
246     /* check min and max values against allocated id */
247     if (node->mint_min != (__u32)((node->mint_prefix << MINT_BIT_SHIFT) | first)) {
248       printf("Min mismatch\n");
249       err ++;
250     }
251     
252     if (node->mint_max != (__u32)((node->mint_prefix << MINT_BIT_SHIFT) | last)) {
253       printf("Max mismatch\n");
254       err ++;
255     }
256   }
257
258   if (err)
259     printf("Errors: %d\n", err);
260
261   return err;
262 }
263
264 int
265 node_check_dump(const char * function, int line, const char *name, 
266                 struct mint *node)
267 {
268   int ret;
269
270   ret = node_check(node);
271
272   if (ret)
273     node_dump(function, line, name, node);
274
275   return ret;
276 }
277
278 /* recursively check nodes:
279  * WARNING: this does not check:
280  *   - against recursive tree,
281  *   - descending level number (assume node checking does the job)
282  */
283 int
284 tree_check(const char * function, int line, const char *name,
285            struct mint **tree)
286 {
287   int i;
288
289   struct mint * node = *tree;
290
291   if (node == NULL)
292     return 0;
293
294   if (node_check_dump(function, line, name, node))
295     return 1;
296
297   if (node->mint_level == 3)
298     return 0;
299
300   for(i = 0; i < 32; i++)
301     {
302       if (node->mint_alloc_bitmap & (1 << i))
303         {
304           if (tree_check(function, line, name, &node->mint_ptr[i]))
305             return 1;
306         }
307     }
308
309   return 0;
310 }