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 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 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 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 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 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 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 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 */ 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 */ 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 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 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 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 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 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 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 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 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 */ 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 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 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