4 * Copyright (C) 2011 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Library
8 * General Public License, version 2.
23 #include <sys/types.h>
30 extern ss_request_table tst_bitmaps_cmds;
32 static char subsystem_name[] = "tst_bitmaps";
33 static char version[] = "1.0";
38 static int source_file(const char *cmd_file, int sci_idx)
46 if (strcmp(cmd_file, "-") == 0)
49 f = fopen(cmd_file, "r");
60 if (fgets(buf, sizeof(buf), f) == NULL)
69 cp = strchr(buf, '\n');
72 cp = strchr(buf, '\r');
76 printf("%s: %s\n", subsystem_name, buf);
77 retval = ss_execute_line(sci_idx, buf);
79 ss_perror(sci_idx, retval, buf);
88 * This function resets the libc getopt() function, which keeps
89 * internal state. Bad design! Stupid libc API designers! No
92 * BSD-derived getopt() functions require that optind be reset to 1 in
93 * order to reset getopt() state. This used to be generally accepted
94 * way of resetting getopt(). However, glibc's getopt()
95 * has additional getopt() state beyond optind, and requires that
96 * optind be set zero to reset its state. So the unfortunate state of
97 * affairs is that BSD-derived versions of getopt() misbehave if
98 * optind is set to 0 in order to reset getopt(), and glibc's getopt()
99 * will core dump if optind is set 1 in order to reset getopt().
101 * More modern versions of BSD require that optreset be set to 1 in
102 * order to reset getopt(). Sigh. Standards, anyone?
104 * We hide the hair here.
106 void reset_getopt(void)
108 #if defined(__GLIBC__) || defined(__linux__)
114 optreset = 1; /* Makes BSD getopt happy */
119 * This function will convert a string to an unsigned long, printing
120 * an error message if it fails, and returning success or failure in err.
122 unsigned long parse_ulong(const char *str, const char *cmd,
123 const char *descr, int *err)
128 ret = strtoul(str, &tmp, 0);
134 com_err(cmd, 0, "Bad %s - %s", descr, str);
143 int check_fs_open(const char *name)
146 com_err(name, 0, "Filesystem not open");
152 static void setup_filesystem(const char *name,
153 unsigned int blocks, unsigned int inodes,
154 unsigned int type, int flags)
156 struct ext2_super_block param;
159 memset(¶m, 0, sizeof(param));
160 ext2fs_blocks_count_set(¶m, blocks);
161 param.s_inodes_count = inodes;
163 retval = ext2fs_initialize("test fs", flags, ¶m,
164 test_io_manager, &test_fs);
167 com_err(name, retval, "while initializing filesystem");
170 test_fs->default_bitmap_type = type;
171 ext2fs_free_block_bitmap(test_fs->block_map);
172 test_fs->block_map = 0;
173 ext2fs_free_inode_bitmap(test_fs->inode_map);
174 test_fs->inode_map = 0;
175 retval = ext2fs_allocate_block_bitmap(test_fs, "block bitmap",
176 &test_fs->block_map);
178 com_err(name, retval, "while allocating block bitmap");
181 retval = ext2fs_allocate_inode_bitmap(test_fs, "inode bitmap",
182 &test_fs->inode_map);
184 com_err(name, retval, "while allocating inode bitmap");
190 ext2fs_close_free(&test_fs);
193 void setup_cmd(int argc, ss_argv_t argv,
194 int sci_idx EXT2FS_ATTR((unused)),
195 void *infop EXT2FS_ATTR((unused)))
198 unsigned int blocks = 128;
199 unsigned int inodes = 0;
200 unsigned int type = EXT2FS_BMAP64_BITARRAY;
201 int flags = EXT2_FLAG_64BITS;
204 ext2fs_close_free(&test_fs);
207 while ((c = getopt(argc, argv, "b:i:lt:")) != EOF) {
210 blocks = parse_ulong(optarg, argv[0],
211 "number of blocks", &err);
216 inodes = parse_ulong(optarg, argv[0],
217 "number of blocks", &err);
221 case 'l': /* Legacy bitmaps */
225 type = parse_ulong(optarg, argv[0],
226 "bitmap backend type", &err);
231 fprintf(stderr, "%s: usage: setup [-b blocks] "
232 "[-i inodes] [-t type]\n", argv[0]);
236 setup_filesystem(argv[0], blocks, inodes, type, flags);
239 void close_cmd(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
240 void *infop EXT2FS_ATTR((unused)))
242 if (check_fs_open(argv[0]))
245 ext2fs_close_free(&test_fs);
249 void dump_bitmap(ext2fs_generic_bitmap bmap, unsigned int start, unsigned num)
253 int i, len = (num - start + 7) / 8;
257 com_err("dump_bitmap", 0, "couldn't allocate buffer");
261 retval = ext2fs_get_generic_bmap_range(bmap, (__u64) start, num, buf);
263 com_err("dump_bitmap", retval,
264 "while calling ext2fs_generic_bmap_range");
268 for (i=0; i < len; i++)
269 printf("%02x", buf[i]);
271 printf("bits set: %u\n", ext2fs_bitcount(buf, len));
275 void dump_inode_bitmap_cmd(int argc, ss_argv_t argv,
276 int sci_idx EXT2FS_ATTR((unused)),
277 void *infop EXT2FS_ATTR((unused)))
279 if (check_fs_open(argv[0]))
282 printf("inode bitmap: ");
283 dump_bitmap(test_fs->inode_map, 1, test_fs->super->s_inodes_count);
286 void dump_block_bitmap_cmd(int argc, ss_argv_t argv,
287 int sci_idx EXT2FS_ATTR((unused)),
288 void *infop EXT2FS_ATTR((unused)))
290 if (check_fs_open(argv[0]))
293 printf("block bitmap: ");
294 dump_bitmap(test_fs->block_map, test_fs->super->s_first_data_block,
295 test_fs->super->s_blocks_count);
298 void do_setb(int argc, ss_argv_t argv,
299 int sci_idx EXT2FS_ATTR((unused)),
300 void *infop EXT2FS_ATTR((unused)))
302 unsigned int block, num;
304 int test_result, op_result;
306 if (check_fs_open(argv[0]))
309 if (argc != 2 && argc != 3) {
310 com_err(argv[0], 0, "Usage: setb <block> [num]");
314 block = parse_ulong(argv[1], argv[0], "block", &err);
319 num = parse_ulong(argv[2], argv[0], "num", &err);
323 ext2fs_mark_block_bitmap_range2(test_fs->block_map,
325 printf("Marking blocks %u to %u\n", block, block + num - 1);
329 test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
330 op_result = ext2fs_mark_block_bitmap2(test_fs->block_map, block);
331 printf("Setting block %u, was %s before\n", block, op_result ?
333 if (!test_result != !op_result)
334 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
335 test_result, op_result);
338 void do_clearb(int argc, ss_argv_t argv,
339 int sci_idx EXT2FS_ATTR((unused)),
340 void *infop EXT2FS_ATTR((unused)))
342 unsigned int block, num;
344 int test_result, op_result;
346 if (check_fs_open(argv[0]))
349 if (argc != 2 && argc != 3) {
350 com_err(argv[0], 0, "Usage: clearb <block> [num]");
354 block = parse_ulong(argv[1], argv[0], "block", &err);
359 num = parse_ulong(argv[2], argv[0], "num", &err);
363 ext2fs_unmark_block_bitmap_range2(test_fs->block_map,
365 printf("Clearing blocks %u to %u\n", block, block + num - 1);
369 test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
370 op_result = ext2fs_unmark_block_bitmap2(test_fs->block_map, block);
371 printf("Clearing block %u, was %s before\n", block, op_result ?
373 if (!test_result != !op_result)
374 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
375 test_result, op_result);
378 void do_testb(int argc, ss_argv_t argv,
379 int sci_idx EXT2FS_ATTR((unused)),
380 void *infop EXT2FS_ATTR((unused)))
382 unsigned int block, num;
386 if (check_fs_open(argv[0]))
389 if (argc != 2 && argc != 3) {
390 com_err(argv[0], 0, "Usage: testb <block> [num]");
394 block = parse_ulong(argv[1], argv[0], "block", &err);
399 num = parse_ulong(argv[2], argv[0], "num", &err);
404 ext2fs_test_block_bitmap_range2(test_fs->block_map,
406 printf("Blocks %u to %u are %sall clear.\n",
407 block, block + num - 1, test_result ? "" : "NOT ");
411 test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
412 printf("Block %u is %s\n", block, test_result ? "set" : "clear");
415 void do_ffzb(int argc, ss_argv_t argv,
416 int sci_idx EXT2FS_ATTR((unused)),
417 void *infop EXT2FS_ATTR((unused)))
419 unsigned int start, end;
424 if (check_fs_open(argv[0]))
427 if (argc != 3 && argc != 3) {
428 com_err(argv[0], 0, "Usage: ffzb <start> <end>");
432 start = parse_ulong(argv[1], argv[0], "start", &err);
436 end = parse_ulong(argv[2], argv[0], "end", &err);
440 retval = ext2fs_find_first_zero_block_bitmap2(test_fs->block_map,
443 printf("ext2fs_find_first_zero_block_bitmap2() returned %s\n",
444 error_message(retval));
447 printf("First unmarked block is %llu\n", (unsigned long long) out);
450 void do_ffsb(int argc, ss_argv_t argv,
451 int sci_idx EXT2FS_ATTR((unused)),
452 void *infop EXT2FS_ATTR((unused)))
454 unsigned int start, end;
459 if (check_fs_open(argv[0]))
462 if (argc != 3 && argc != 3) {
463 com_err(argv[0], 0, "Usage: ffsb <start> <end>");
467 start = parse_ulong(argv[1], argv[0], "start", &err);
471 end = parse_ulong(argv[2], argv[0], "end", &err);
475 retval = ext2fs_find_first_set_block_bitmap2(test_fs->block_map,
478 printf("ext2fs_find_first_set_block_bitmap2() returned %s\n",
479 error_message(retval));
482 printf("First marked block is %llu\n", (unsigned long long) out);
486 void do_zerob(int argc, ss_argv_t argv,
487 int sci_idx EXT2FS_ATTR((unused)),
488 void *infop EXT2FS_ATTR((unused)))
490 if (check_fs_open(argv[0]))
493 printf("Clearing block bitmap.\n");
494 ext2fs_clear_block_bitmap(test_fs->block_map);
497 void do_seti(int argc, ss_argv_t argv,
498 int sci_idx EXT2FS_ATTR((unused)),
499 void *infop EXT2FS_ATTR((unused)))
503 int test_result, op_result;
505 if (check_fs_open(argv[0]))
509 com_err(argv[0], 0, "Usage: seti <inode>");
513 inode = parse_ulong(argv[1], argv[0], "inode", &err);
517 test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
518 op_result = ext2fs_mark_inode_bitmap2(test_fs->inode_map, inode);
519 printf("Setting inode %u, was %s before\n", inode, op_result ?
521 if (!test_result != !op_result) {
522 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
523 test_result, op_result);
528 void do_cleari(int argc, ss_argv_t argv,
529 int sci_idx EXT2FS_ATTR((unused)),
530 void *infop EXT2FS_ATTR((unused)))
534 int test_result, op_result;
536 if (check_fs_open(argv[0]))
540 com_err(argv[0], 0, "Usage: clearb <inode>");
544 inode = parse_ulong(argv[1], argv[0], "inode", &err);
548 test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
549 op_result = ext2fs_unmark_inode_bitmap2(test_fs->inode_map, inode);
550 printf("Clearing inode %u, was %s before\n", inode, op_result ?
552 if (!test_result != !op_result) {
553 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
554 test_result, op_result);
559 void do_testi(int argc, ss_argv_t argv,
560 int sci_idx EXT2FS_ATTR((unused)),
561 void *infop EXT2FS_ATTR((unused)))
567 if (check_fs_open(argv[0]))
571 com_err(argv[0], 0, "Usage: testb <inode>");
575 inode = parse_ulong(argv[1], argv[0], "inode", &err);
579 test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
580 printf("Inode %u is %s\n", inode, test_result ? "set" : "clear");
583 void do_ffzi(int argc, ss_argv_t argv,
584 int sci_idx EXT2FS_ATTR((unused)),
585 void *infop EXT2FS_ATTR((unused)))
587 unsigned int start, end;
592 if (check_fs_open(argv[0]))
595 if (argc != 3 && argc != 3) {
596 com_err(argv[0], 0, "Usage: ffzi <start> <end>");
600 start = parse_ulong(argv[1], argv[0], "start", &err);
604 end = parse_ulong(argv[2], argv[0], "end", &err);
608 retval = ext2fs_find_first_zero_inode_bitmap2(test_fs->inode_map,
611 printf("ext2fs_find_first_zero_inode_bitmap2() returned %s\n",
612 error_message(retval));
615 printf("First unmarked inode is %u\n", out);
618 void do_ffsi(int argc, ss_argv_t argv,
619 int sci_idx EXT2FS_ATTR((unused)),
620 void *infop EXT2FS_ATTR((unused)))
622 unsigned int start, end;
627 if (check_fs_open(argv[0]))
630 if (argc != 3 && argc != 3) {
631 com_err(argv[0], 0, "Usage: ffsi <start> <end>");
635 start = parse_ulong(argv[1], argv[0], "start", &err);
639 end = parse_ulong(argv[2], argv[0], "end", &err);
643 retval = ext2fs_find_first_set_inode_bitmap2(test_fs->inode_map,
646 printf("ext2fs_find_first_set_inode_bitmap2() returned %s\n",
647 error_message(retval));
650 printf("First marked inode is %u\n", out);
653 void do_zeroi(int argc, ss_argv_t argv,
654 int sci_idx EXT2FS_ATTR((unused)),
655 void *infop EXT2FS_ATTR((unused)))
657 if (check_fs_open(argv[0]))
660 printf("Clearing inode bitmap.\n");
661 ext2fs_clear_inode_bitmap(test_fs->inode_map);
664 int main(int argc, char **argv)
666 unsigned int blocks = 128;
667 unsigned int inodes = 0;
668 unsigned int type = EXT2FS_BMAP64_BITARRAY;
670 char *request = (char *)NULL;
673 int flags = EXT2_FLAG_64BITS;
675 add_error_table(&et_ss_error_table);
676 add_error_table(&et_ext2_error_table);
677 while ((c = getopt (argc, argv, "b:i:lt:R:f:")) != EOF) {
680 blocks = parse_ulong(optarg, argv[0],
681 "number of blocks", &err);
686 inodes = parse_ulong(optarg, argv[0],
687 "number of blocks", &err);
691 case 'l': /* Legacy bitmaps */
695 type = parse_ulong(optarg, argv[0],
696 "bitmap backend type", &err);
707 com_err(argv[0], 0, "Usage: %s [-R request] "
708 "[-f cmd_file]", subsystem_name);
713 sci_idx = ss_create_invocation(subsystem_name, version,
714 (char *)NULL, &tst_bitmaps_cmds, &code);
716 ss_perror(sci_idx, code, "creating invocation");
720 (void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &code);
722 ss_perror(sci_idx, code, "adding standard requests");
726 printf("%s %s. Type '?' for a list of commands.\n\n",
727 subsystem_name, version);
729 setup_filesystem(argv[0], blocks, inodes, type, flags);
732 code = ss_execute_line(sci_idx, request);
734 ss_perror(sci_idx, code, request);
737 } else if (cmd_file) {
738 exit_status = source_file(cmd_file, sci_idx);