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
45struct ext2_icount_el {
46	ext2_ino_t	ino;
47	__u32		count;
48};
49
50struct 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
75void 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
99static 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
129errout:
130	ext2fs_free_icount(icount);
131	return(retval);
132}
133
134#ifdef CONFIG_TDB
135struct 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
143static 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
169static 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
183errcode_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;
233errout:
234	ext2fs_free_icount(icount);
235	return(retval);
236#else
237	return EXT2_ET_UNIMPLEMENTED;
238#endif
239}
240
241errcode_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
301errout:
302	ext2fs_free_icount(icount);
303	return(retval);
304}
305
306errcode_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 */
317static 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 */
368static 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
412static 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
444static 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
476errcode_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
499errcode_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
521errcode_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
578errcode_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
621errcode_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
656ext2_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
666ext2_filsys	test_fs;
667ext2_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
675struct test_program {
676	int		cmd;
677	ext2_ino_t	ino;
678	__u16		arg;
679	__u16		expected;
680};
681
682struct 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
708struct 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 */
745static void setup(void)
746{
747	errcode_t	retval;
748	struct ext2_super_block param;
749
750	initialize_ext2_error_table();
751
752	memset(&param, 0, sizeof(param));
753	ext2fs_blocks_count_set(&param, 12000);
754
755	retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, &param,
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
770int 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
854int 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