1 /*
2 * icount.c --- an efficient inode count abstraction
3 *
4 * Copyright (C) 1997 Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Library
8 * General Public License, version 2.
9 * %End-Header%
10 */
11
12 #include "config.h"
13 #if HAVE_UNISTD_H
14 #include <unistd.h>
15 #endif
16 #include <string.h>
17 #include <stdio.h>
18 #include <sys/stat.h>
19 #include <fcntl.h>
20 #include <errno.h>
21
22 #include "ext2_fs.h"
23 #include "ext2fs.h"
24 #include "tdb.h"
25
26 /*
27 * The data storage strategy used by icount relies on the observation
28 * that most inode counts are either zero (for non-allocated inodes),
29 * one (for most files), and only a few that are two or more
30 * (directories and files that are linked to more than one directory).
31 *
32 * Also, e2fsck tends to load the icount data sequentially.
33 *
34 * So, we use an inode bitmap to indicate which inodes have a count of
35 * one, and then use a sorted list to store the counts for inodes
36 * which are greater than one.
37 *
38 * We also use an optional bitmap to indicate which inodes are already
39 * in the sorted list, to speed up the use of this abstraction by
40 * e2fsck's pass 2. Pass 2 increments inode counts as it finds them,
41 * so this extra bitmap avoids searching the sorted list to see if a
42 * particular inode is on the sorted list already.
43 */
44
45 struct ext2_icount_el {
46 ext2_ino_t ino;
47 __u32 count;
48 };
49
50 struct ext2_icount {
51 errcode_t magic;
52 ext2fs_inode_bitmap single;
53 ext2fs_inode_bitmap multiple;
54 ext2_ino_t count;
55 ext2_ino_t size;
56 ext2_ino_t num_inodes;
57 ext2_ino_t cursor;
58 struct ext2_icount_el *list;
59 struct ext2_icount_el *last_lookup;
60 #ifdef CONFIG_TDB
61 char *tdb_fn;
62 TDB_CONTEXT *tdb;
63 #endif
64 };
65
66 /*
67 * We now use a 32-bit counter field because it doesn't cost us
68 * anything extra for the in-memory data structure, due to alignment
69 * padding. But there's no point changing the interface if most of
70 * the time we only care if the number is bigger than 65,000 or not.
71 * So use the following translation function to return a 16-bit count.
72 */
73 #define icount_16_xlate(x) (((x) > 65500) ? 65500 : (x))
74
ext2fs_free_icount(ext2_icount_t icount)75 void ext2fs_free_icount(ext2_icount_t icount)
76 {
77 if (!icount)
78 return;
79
80 icount->magic = 0;
81 if (icount->list)
82 ext2fs_free_mem(&icount->list);
83 if (icount->single)
84 ext2fs_free_inode_bitmap(icount->single);
85 if (icount->multiple)
86 ext2fs_free_inode_bitmap(icount->multiple);
87 #ifdef CONFIG_TDB
88 if (icount->tdb)
89 tdb_close(icount->tdb);
90 if (icount->tdb_fn) {
91 unlink(icount->tdb_fn);
92 free(icount->tdb_fn);
93 }
94 #endif
95
96 ext2fs_free_mem(&icount);
97 }
98
alloc_icount(ext2_filsys fs,int flags,ext2_icount_t * ret)99 static errcode_t alloc_icount(ext2_filsys fs, int flags, ext2_icount_t *ret)
100 {
101 ext2_icount_t icount;
102 errcode_t retval;
103
104 *ret = 0;
105
106 retval = ext2fs_get_mem(sizeof(struct ext2_icount), &icount);
107 if (retval)
108 return retval;
109 memset(icount, 0, sizeof(struct ext2_icount));
110
111 retval = ext2fs_allocate_inode_bitmap(fs, "icount", &icount->single);
112 if (retval)
113 goto errout;
114
115 if (flags & EXT2_ICOUNT_OPT_INCREMENT) {
116 retval = ext2fs_allocate_inode_bitmap(fs, "icount_inc",
117 &icount->multiple);
118 if (retval)
119 goto errout;
120 } else
121 icount->multiple = 0;
122
123 icount->magic = EXT2_ET_MAGIC_ICOUNT;
124 icount->num_inodes = fs->super->s_inodes_count;
125
126 *ret = icount;
127 return 0;
128
129 errout:
130 ext2fs_free_icount(icount);
131 return(retval);
132 }
133
134 #ifdef CONFIG_TDB
135 struct uuid {
136 __u32 time_low;
137 __u16 time_mid;
138 __u16 time_hi_and_version;
139 __u16 clock_seq;
140 __u8 node[6];
141 };
142
unpack_uuid(void * in,struct uuid * uu)143 static void unpack_uuid(void *in, struct uuid *uu)
144 {
145 __u8 *ptr = in;
146 __u32 tmp;
147
148 tmp = *ptr++;
149 tmp = (tmp << 8) | *ptr++;
150 tmp = (tmp << 8) | *ptr++;
151 tmp = (tmp << 8) | *ptr++;
152 uu->time_low = tmp;
153
154 tmp = *ptr++;
155 tmp = (tmp << 8) | *ptr++;
156 uu->time_mid = tmp;
157
158 tmp = *ptr++;
159 tmp = (tmp << 8) | *ptr++;
160 uu->time_hi_and_version = tmp;
161
162 tmp = *ptr++;
163 tmp = (tmp << 8) | *ptr++;
164 uu->clock_seq = tmp;
165
166 memcpy(uu->node, ptr, 6);
167 }
168
uuid_unparse(void * uu,char * out)169 static void uuid_unparse(void *uu, char *out)
170 {
171 struct uuid uuid;
172
173 unpack_uuid(uu, &uuid);
174 sprintf(out,
175 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
176 uuid.time_low, uuid.time_mid, uuid.time_hi_and_version,
177 uuid.clock_seq >> 8, uuid.clock_seq & 0xFF,
178 uuid.node[0], uuid.node[1], uuid.node[2],
179 uuid.node[3], uuid.node[4], uuid.node[5]);
180 }
181 #endif
182
ext2fs_create_icount_tdb(ext2_filsys fs EXT2FS_NO_TDB_UNUSED,char * tdb_dir EXT2FS_NO_TDB_UNUSED,int flags EXT2FS_NO_TDB_UNUSED,ext2_icount_t * ret EXT2FS_NO_TDB_UNUSED)183 errcode_t ext2fs_create_icount_tdb(ext2_filsys fs EXT2FS_NO_TDB_UNUSED,
184 char *tdb_dir EXT2FS_NO_TDB_UNUSED,
185 int flags EXT2FS_NO_TDB_UNUSED,
186 ext2_icount_t *ret EXT2FS_NO_TDB_UNUSED)
187 {
188 #ifdef CONFIG_TDB
189 ext2_icount_t icount;
190 errcode_t retval;
191 char *fn, uuid[40];
192 ext2_ino_t num_inodes;
193 mode_t save_umask;
194 int fd;
195
196 retval = alloc_icount(fs, flags, &icount);
197 if (retval)
198 return retval;
199
200 retval = ext2fs_get_mem(strlen(tdb_dir) + 64, &fn);
201 if (retval)
202 goto errout;
203 uuid_unparse(fs->super->s_uuid, uuid);
204 sprintf(fn, "%s/%s-icount-XXXXXX", tdb_dir, uuid);
205 save_umask = umask(077);
206 fd = mkstemp(fn);
207 if (fd < 0) {
208 retval = errno;
209 ext2fs_free_mem(&fn);
210 goto errout;
211 }
212 icount->tdb_fn = fn;
213 umask(save_umask);
214 /*
215 * This is an overestimate of the size that we will need; the
216 * ideal value is the number of used inodes with a count
217 * greater than 1. OTOH the times when we really need this is
218 * with the backup programs that use lots of hard links, in
219 * which case the number of inodes in use approaches the ideal
220 * value.
221 */
222 num_inodes = fs->super->s_inodes_count - fs->super->s_free_inodes_count;
223
224 icount->tdb = tdb_open(fn, num_inodes, TDB_NOLOCK | TDB_NOSYNC,
225 O_RDWR | O_CREAT | O_TRUNC, 0600);
226 close(fd);
227 if (icount->tdb == NULL) {
228 retval = errno;
229 goto errout;
230 }
231 *ret = icount;
232 return 0;
233 errout:
234 ext2fs_free_icount(icount);
235 return(retval);
236 #else
237 return EXT2_ET_UNIMPLEMENTED;
238 #endif
239 }
240
ext2fs_create_icount2(ext2_filsys fs,int flags,unsigned int size,ext2_icount_t hint,ext2_icount_t * ret)241 errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, unsigned int size,
242 ext2_icount_t hint, ext2_icount_t *ret)
243 {
244 ext2_icount_t icount;
245 errcode_t retval;
246 size_t bytes;
247 ext2_ino_t i;
248
249 if (hint) {
250 EXT2_CHECK_MAGIC(hint, EXT2_ET_MAGIC_ICOUNT);
251 if (hint->size > size)
252 size = (size_t) hint->size;
253 }
254
255 retval = alloc_icount(fs, flags, &icount);
256 if (retval)
257 return retval;
258
259 if (size) {
260 icount->size = size;
261 } else {
262 /*
263 * Figure out how many special case inode counts we will
264 * have. We know we will need one for each directory;
265 * we also need to reserve some extra room for file links
266 */
267 retval = ext2fs_get_num_dirs(fs, &icount->size);
268 if (retval)
269 goto errout;
270 icount->size += fs->super->s_inodes_count / 50;
271 }
272
273 bytes = (size_t) (icount->size * sizeof(struct ext2_icount_el));
274 #if 0
275 printf("Icount allocated %u entries, %d bytes.\n",
276 icount->size, bytes);
277 #endif
278 retval = ext2fs_get_array(icount->size, sizeof(struct ext2_icount_el),
279 &icount->list);
280 if (retval)
281 goto errout;
282 memset(icount->list, 0, bytes);
283
284 icount->count = 0;
285 icount->cursor = 0;
286
287 /*
288 * Populate the sorted list with those entries which were
289 * found in the hint icount (since those are ones which will
290 * likely need to be in the sorted list this time around).
291 */
292 if (hint) {
293 for (i=0; i < hint->count; i++)
294 icount->list[i].ino = hint->list[i].ino;
295 icount->count = hint->count;
296 }
297
298 *ret = icount;
299 return 0;
300
301 errout:
302 ext2fs_free_icount(icount);
303 return(retval);
304 }
305
ext2fs_create_icount(ext2_filsys fs,int flags,unsigned int size,ext2_icount_t * ret)306 errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
307 unsigned int size,
308 ext2_icount_t *ret)
309 {
310 return ext2fs_create_icount2(fs, flags, size, 0, ret);
311 }
312
313 /*
314 * insert_icount_el() --- Insert a new entry into the sorted list at a
315 * specified position.
316 */
insert_icount_el(ext2_icount_t icount,ext2_ino_t ino,int pos)317 static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount,
318 ext2_ino_t ino, int pos)
319 {
320 struct ext2_icount_el *el;
321 errcode_t retval;
322 ext2_ino_t new_size = 0;
323 int num;
324
325 if (icount->last_lookup && icount->last_lookup->ino == ino)
326 return icount->last_lookup;
327
328 if (icount->count >= icount->size) {
329 if (icount->count) {
330 new_size = icount->list[(unsigned)icount->count-1].ino;
331 new_size = (ext2_ino_t) (icount->count *
332 ((float) icount->num_inodes / new_size));
333 }
334 if (new_size < (icount->size + 100))
335 new_size = icount->size + 100;
336 #if 0
337 printf("Reallocating icount %u entries...\n", new_size);
338 #endif
339 retval = ext2fs_resize_mem((size_t) icount->size *
340 sizeof(struct ext2_icount_el),
341 (size_t) new_size *
342 sizeof(struct ext2_icount_el),
343 &icount->list);
344 if (retval)
345 return 0;
346 icount->size = new_size;
347 }
348 num = (int) icount->count - pos;
349 if (num < 0)
350 return 0; /* should never happen */
351 if (num) {
352 memmove(&icount->list[pos+1], &icount->list[pos],
353 sizeof(struct ext2_icount_el) * num);
354 }
355 icount->count++;
356 el = &icount->list[pos];
357 el->count = 0;
358 el->ino = ino;
359 icount->last_lookup = el;
360 return el;
361 }
362
363 /*
364 * get_icount_el() --- given an inode number, try to find icount
365 * information in the sorted list. If the create flag is set,
366 * and we can't find an entry, create one in the sorted list.
367 */
get_icount_el(ext2_icount_t icount,ext2_ino_t ino,int create)368 static struct ext2_icount_el *get_icount_el(ext2_icount_t icount,
369 ext2_ino_t ino, int create)
370 {
371 int low, high, mid;
372
373 if (!icount || !icount->list)
374 return 0;
375
376 if (create && ((icount->count == 0) ||
377 (ino > icount->list[(unsigned)icount->count-1].ino))) {
378 return insert_icount_el(icount, ino, (unsigned) icount->count);
379 }
380 if (icount->count == 0)
381 return 0;
382
383 if (icount->cursor >= icount->count)
384 icount->cursor = 0;
385 if (ino == icount->list[icount->cursor].ino)
386 return &icount->list[icount->cursor++];
387 #if 0
388 printf("Non-cursor get_icount_el: %u\n", ino);
389 #endif
390 low = 0;
391 high = (int) icount->count-1;
392 while (low <= high) {
393 mid = ((unsigned)low + (unsigned)high) >> 1;
394 if (ino == icount->list[mid].ino) {
395 icount->cursor = mid+1;
396 return &icount->list[mid];
397 }
398 if (ino < icount->list[mid].ino)
399 high = mid-1;
400 else
401 low = mid+1;
402 }
403 /*
404 * If we need to create a new entry, it should be right at
405 * low (where high will be left at low-1).
406 */
407 if (create)
408 return insert_icount_el(icount, ino, low);
409 return 0;
410 }
411
set_inode_count(ext2_icount_t icount,ext2_ino_t ino,__u32 count)412 static errcode_t set_inode_count(ext2_icount_t icount, ext2_ino_t ino,
413 __u32 count)
414 {
415 struct ext2_icount_el *el;
416 #ifdef CONFIG_TDB
417 TDB_DATA key, data;
418
419 if (icount->tdb) {
420 key.dptr = (unsigned char *) &ino;
421 key.dsize = sizeof(ext2_ino_t);
422 data.dptr = (unsigned char *) &count;
423 data.dsize = sizeof(__u32);
424 if (count) {
425 if (tdb_store(icount->tdb, key, data, TDB_REPLACE))
426 return tdb_error(icount->tdb) +
427 EXT2_ET_TDB_SUCCESS;
428 } else {
429 if (tdb_delete(icount->tdb, key))
430 return tdb_error(icount->tdb) +
431 EXT2_ET_TDB_SUCCESS;
432 }
433 return 0;
434 }
435 #endif
436 el = get_icount_el(icount, ino, 1);
437 if (!el)
438 return EXT2_ET_NO_MEMORY;
439
440 el->count = count;
441 return 0;
442 }
443
get_inode_count(ext2_icount_t icount,ext2_ino_t ino,__u32 * count)444 static errcode_t get_inode_count(ext2_icount_t icount, ext2_ino_t ino,
445 __u32 *count)
446 {
447 struct ext2_icount_el *el;
448 #ifdef CONFIG_TDB
449 TDB_DATA key, data;
450
451 if (icount->tdb) {
452 key.dptr = (unsigned char *) &ino;
453 key.dsize = sizeof(ext2_ino_t);
454
455 data = tdb_fetch(icount->tdb, key);
456 if (data.dptr == NULL) {
457 *count = 0;
458 return tdb_error(icount->tdb) + EXT2_ET_TDB_SUCCESS;
459 }
460
461 *count = *((__u32 *) data.dptr);
462 free(data.dptr);
463 return 0;
464 }
465 #endif
466 el = get_icount_el(icount, ino, 0);
467 if (!el) {
468 *count = 0;
469 return ENOENT;
470 }
471
472 *count = el->count;
473 return 0;
474 }
475
ext2fs_icount_validate(ext2_icount_t icount,FILE * out)476 errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *out)
477 {
478 errcode_t ret = 0;
479 unsigned int i;
480 const char *bad = "bad icount";
481
482 EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
483
484 if (icount->count > icount->size) {
485 fprintf(out, "%s: count > size\n", bad);
486 return EXT2_ET_INVALID_ARGUMENT;
487 }
488 for (i=1; i < icount->count; i++) {
489 if (icount->list[i-1].ino >= icount->list[i].ino) {
490 fprintf(out, "%s: list[%d].ino=%u, list[%d].ino=%u\n",
491 bad, i-1, icount->list[i-1].ino,
492 i, icount->list[i].ino);
493 ret = EXT2_ET_INVALID_ARGUMENT;
494 }
495 }
496 return ret;
497 }
498
ext2fs_icount_fetch(ext2_icount_t icount,ext2_ino_t ino,__u16 * ret)499 errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino, __u16 *ret)
500 {
501 __u32 val;
502 EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
503
504 if (!ino || (ino > icount->num_inodes))
505 return EXT2_ET_INVALID_ARGUMENT;
506
507 if (ext2fs_test_inode_bitmap2(icount->single, ino)) {
508 *ret = 1;
509 return 0;
510 }
511 if (icount->multiple &&
512 !ext2fs_test_inode_bitmap2(icount->multiple, ino)) {
513 *ret = 0;
514 return 0;
515 }
516 get_inode_count(icount, ino, &val);
517 *ret = icount_16_xlate(val);
518 return 0;
519 }
520
ext2fs_icount_increment(ext2_icount_t icount,ext2_ino_t ino,__u16 * ret)521 errcode_t ext2fs_icount_increment(ext2_icount_t icount, ext2_ino_t ino,
522 __u16 *ret)
523 {
524 __u32 curr_value;
525
526 EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
527
528 if (!ino || (ino > icount->num_inodes))
529 return EXT2_ET_INVALID_ARGUMENT;
530
531 if (ext2fs_test_inode_bitmap2(icount->single, ino)) {
532 /*
533 * If the existing count is 1, then we know there is
534 * no entry in the list.
535 */
536 if (set_inode_count(icount, ino, 2))
537 return EXT2_ET_NO_MEMORY;
538 curr_value = 2;
539 ext2fs_unmark_inode_bitmap2(icount->single, ino);
540 } else if (icount->multiple) {
541 /*
542 * The count is either zero or greater than 1; if the
543 * inode is set in icount->multiple, then there should
544 * be an entry in the list, so we need to fix it.
545 */
546 if (ext2fs_test_inode_bitmap2(icount->multiple, ino)) {
547 get_inode_count(icount, ino, &curr_value);
548 curr_value++;
549 if (set_inode_count(icount, ino, curr_value))
550 return EXT2_ET_NO_MEMORY;
551 } else {
552 /*
553 * The count was zero; mark the single bitmap
554 * and return.
555 */
556 ext2fs_mark_inode_bitmap2(icount->single, ino);
557 if (ret)
558 *ret = 1;
559 return 0;
560 }
561 } else {
562 /*
563 * The count is either zero or greater than 1; try to
564 * find an entry in the list to determine which.
565 */
566 get_inode_count(icount, ino, &curr_value);
567 curr_value++;
568 if (set_inode_count(icount, ino, curr_value))
569 return EXT2_ET_NO_MEMORY;
570 }
571 if (icount->multiple)
572 ext2fs_mark_inode_bitmap2(icount->multiple, ino);
573 if (ret)
574 *ret = icount_16_xlate(curr_value);
575 return 0;
576 }
577
ext2fs_icount_decrement(ext2_icount_t icount,ext2_ino_t ino,__u16 * ret)578 errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
579 __u16 *ret)
580 {
581 __u32 curr_value;
582
583 if (!ino || (ino > icount->num_inodes))
584 return EXT2_ET_INVALID_ARGUMENT;
585
586 EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
587
588 if (ext2fs_test_inode_bitmap2(icount->single, ino)) {
589 ext2fs_unmark_inode_bitmap2(icount->single, ino);
590 if (icount->multiple)
591 ext2fs_unmark_inode_bitmap2(icount->multiple, ino);
592 else {
593 set_inode_count(icount, ino, 0);
594 }
595 if (ret)
596 *ret = 0;
597 return 0;
598 }
599
600 if (icount->multiple &&
601 !ext2fs_test_inode_bitmap2(icount->multiple, ino))
602 return EXT2_ET_INVALID_ARGUMENT;
603
604 get_inode_count(icount, ino, &curr_value);
605 if (!curr_value)
606 return EXT2_ET_INVALID_ARGUMENT;
607 curr_value--;
608 if (set_inode_count(icount, ino, curr_value))
609 return EXT2_ET_NO_MEMORY;
610
611 if (curr_value == 1)
612 ext2fs_mark_inode_bitmap2(icount->single, ino);
613 if ((curr_value == 0) && icount->multiple)
614 ext2fs_unmark_inode_bitmap2(icount->multiple, ino);
615
616 if (ret)
617 *ret = icount_16_xlate(curr_value);
618 return 0;
619 }
620
ext2fs_icount_store(ext2_icount_t icount,ext2_ino_t ino,__u16 count)621 errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
622 __u16 count)
623 {
624 if (!ino || (ino > icount->num_inodes))
625 return EXT2_ET_INVALID_ARGUMENT;
626
627 EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
628
629 if (count == 1) {
630 ext2fs_mark_inode_bitmap2(icount->single, ino);
631 if (icount->multiple)
632 ext2fs_unmark_inode_bitmap2(icount->multiple, ino);
633 return 0;
634 }
635 if (count == 0) {
636 ext2fs_unmark_inode_bitmap2(icount->single, ino);
637 if (icount->multiple) {
638 /*
639 * If the icount->multiple bitmap is enabled,
640 * we can just clear both bitmaps and we're done
641 */
642 ext2fs_unmark_inode_bitmap2(icount->multiple, ino);
643 } else
644 set_inode_count(icount, ino, 0);
645 return 0;
646 }
647
648 if (set_inode_count(icount, ino, count))
649 return EXT2_ET_NO_MEMORY;
650 ext2fs_unmark_inode_bitmap2(icount->single, ino);
651 if (icount->multiple)
652 ext2fs_mark_inode_bitmap2(icount->multiple, ino);
653 return 0;
654 }
655
ext2fs_get_icount_size(ext2_icount_t icount)656 ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount)
657 {
658 if (!icount || icount->magic != EXT2_ET_MAGIC_ICOUNT)
659 return 0;
660
661 return icount->size;
662 }
663
664 #ifdef DEBUG
665
666 ext2_filsys test_fs;
667 ext2_icount_t icount;
668
669 #define EXIT 0x00
670 #define FETCH 0x01
671 #define STORE 0x02
672 #define INCREMENT 0x03
673 #define DECREMENT 0x04
674
675 struct test_program {
676 int cmd;
677 ext2_ino_t ino;
678 __u16 arg;
679 __u16 expected;
680 };
681
682 struct test_program prog[] = {
683 { STORE, 42, 42, 42 },
684 { STORE, 1, 1, 1 },
685 { STORE, 2, 2, 2 },
686 { STORE, 3, 3, 3 },
687 { STORE, 10, 1, 1 },
688 { STORE, 42, 0, 0 },
689 { INCREMENT, 5, 0, 1 },
690 { INCREMENT, 5, 0, 2 },
691 { INCREMENT, 5, 0, 3 },
692 { INCREMENT, 5, 0, 4 },
693 { DECREMENT, 5, 0, 3 },
694 { DECREMENT, 5, 0, 2 },
695 { DECREMENT, 5, 0, 1 },
696 { DECREMENT, 5, 0, 0 },
697 { FETCH, 10, 0, 1 },
698 { FETCH, 1, 0, 1 },
699 { FETCH, 2, 0, 2 },
700 { FETCH, 3, 0, 3 },
701 { INCREMENT, 1, 0, 2 },
702 { DECREMENT, 2, 0, 1 },
703 { DECREMENT, 2, 0, 0 },
704 { FETCH, 12, 0, 0 },
705 { EXIT, 0, 0, 0 }
706 };
707
708 struct test_program extended[] = {
709 { STORE, 1, 1, 1 },
710 { STORE, 2, 2, 2 },
711 { STORE, 3, 3, 3 },
712 { STORE, 4, 4, 4 },
713 { STORE, 5, 5, 5 },
714 { STORE, 6, 1, 1 },
715 { STORE, 7, 2, 2 },
716 { STORE, 8, 3, 3 },
717 { STORE, 9, 4, 4 },
718 { STORE, 10, 5, 5 },
719 { STORE, 11, 1, 1 },
720 { STORE, 12, 2, 2 },
721 { STORE, 13, 3, 3 },
722 { STORE, 14, 4, 4 },
723 { STORE, 15, 5, 5 },
724 { STORE, 16, 1, 1 },
725 { STORE, 17, 2, 2 },
726 { STORE, 18, 3, 3 },
727 { STORE, 19, 4, 4 },
728 { STORE, 20, 5, 5 },
729 { STORE, 21, 1, 1 },
730 { STORE, 22, 2, 2 },
731 { STORE, 23, 3, 3 },
732 { STORE, 24, 4, 4 },
733 { STORE, 25, 5, 5 },
734 { STORE, 26, 1, 1 },
735 { STORE, 27, 2, 2 },
736 { STORE, 28, 3, 3 },
737 { STORE, 29, 4, 4 },
738 { STORE, 30, 5, 5 },
739 { EXIT, 0, 0, 0 }
740 };
741
742 /*
743 * Setup the variables for doing the inode scan test.
744 */
setup(void)745 static void setup(void)
746 {
747 errcode_t retval;
748 struct ext2_super_block param;
749
750 initialize_ext2_error_table();
751
752 memset(¶m, 0, sizeof(param));
753 ext2fs_blocks_count_set(¶m, 12000);
754
755 retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m,
756 test_io_manager, &test_fs);
757 if (retval) {
758 com_err("setup", retval,
759 "while initializing filesystem");
760 exit(1);
761 }
762 retval = ext2fs_allocate_tables(test_fs);
763 if (retval) {
764 com_err("setup", retval,
765 "while allocating tables for test filesystem");
766 exit(1);
767 }
768 }
769
run_test(int flags,int size,char * dir,struct test_program * prog)770 int run_test(int flags, int size, char *dir, struct test_program *prog)
771 {
772 errcode_t retval;
773 ext2_icount_t icount;
774 struct test_program *pc;
775 __u16 result;
776 int problem = 0;
777
778 if (dir) {
779 #ifdef CONFIG_TDB
780 retval = ext2fs_create_icount_tdb(test_fs, dir,
781 flags, &icount);
782 if (retval) {
783 com_err("run_test", retval,
784 "while creating icount using tdb");
785 exit(1);
786 }
787 #else
788 printf("Skipped\n");
789 return 0;
790 #endif
791 } else {
792 retval = ext2fs_create_icount2(test_fs, flags, size, 0,
793 &icount);
794 if (retval) {
795 com_err("run_test", retval, "while creating icount");
796 exit(1);
797 }
798 }
799 for (pc = prog; pc->cmd != EXIT; pc++) {
800 switch (pc->cmd) {
801 case FETCH:
802 printf("icount_fetch(%u) = ", pc->ino);
803 break;
804 case STORE:
805 retval = ext2fs_icount_store(icount, pc->ino, pc->arg);
806 if (retval) {
807 com_err("run_test", retval,
808 "while calling icount_store");
809 exit(1);
810 }
811 printf("icount_store(%u, %u) = ", pc->ino, pc->arg);
812 break;
813 case INCREMENT:
814 retval = ext2fs_icount_increment(icount, pc->ino, 0);
815 if (retval) {
816 com_err("run_test", retval,
817 "while calling icount_increment");
818 exit(1);
819 }
820 printf("icount_increment(%u) = ", pc->ino);
821 break;
822 case DECREMENT:
823 retval = ext2fs_icount_decrement(icount, pc->ino, 0);
824 if (retval) {
825 com_err("run_test", retval,
826 "while calling icount_decrement");
827 exit(1);
828 }
829 printf("icount_decrement(%u) = ", pc->ino);
830 break;
831 }
832 retval = ext2fs_icount_fetch(icount, pc->ino, &result);
833 if (retval) {
834 com_err("run_test", retval,
835 "while calling icount_fetch");
836 exit(1);
837 }
838 printf("%u (%s)\n", result, (result == pc->expected) ?
839 "OK" : "NOT OK");
840 if (result != pc->expected)
841 problem++;
842 }
843 printf("icount size is %u\n", ext2fs_get_icount_size(icount));
844 retval = ext2fs_icount_validate(icount, stdout);
845 if (retval) {
846 com_err("run_test", retval, "while calling icount_validate");
847 exit(1);
848 }
849 ext2fs_free_icount(icount);
850 return problem;
851 }
852
853
main(int argc,char ** argv)854 int main(int argc, char **argv)
855 {
856 int failed = 0;
857
858 setup();
859 printf("Standard icount run:\n");
860 failed += run_test(0, 0, 0, prog);
861 printf("\nMultiple bitmap test:\n");
862 failed += run_test(EXT2_ICOUNT_OPT_INCREMENT, 0, 0, prog);
863 printf("\nResizing icount:\n");
864 failed += run_test(0, 3, 0, extended);
865 printf("\nStandard icount run with tdb:\n");
866 failed += run_test(0, 0, ".", prog);
867 printf("\nMultiple bitmap test with tdb:\n");
868 failed += run_test(EXT2_ICOUNT_OPT_INCREMENT, 0, ".", prog);
869 if (failed)
870 printf("FAILED!\n");
871 return failed;
872 }
873 #endif
874