icount.c

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