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