1 /*
2 * tst_bitmaps.c
3 *
4 * Copyright (C) 2011 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 #include <unistd.h>
14 #include <stdlib.h>
15 #include <stdio.h>
16 #ifdef HAVE_GETOPT_H
17 #include <getopt.h>
18 #endif
19 #include <string.h>
20 #include <fcntl.h>
21 #include <time.h>
22 #include <sys/stat.h>
23 #include <sys/types.h>
24 #include "ss/ss.h"
25
26 #include "ext2_fs.h"
27 #include "ext2fs.h"
28 #include "ext2fsP.h"
29
30 extern ss_request_table tst_bitmaps_cmds;
31
32 static char subsystem_name[] = "tst_bitmaps";
33 static char version[] = "1.0";
34
35 ext2_filsys test_fs;
36 int exit_status = 0;
37
source_file(const char * cmd_file,int sci_idx)38 static int source_file(const char *cmd_file, int sci_idx)
39 {
40 FILE *f;
41 char buf[256];
42 char *cp;
43 int retval;
44 int noecho;
45
46 if (strcmp(cmd_file, "-") == 0)
47 f = stdin;
48 else {
49 f = fopen(cmd_file, "r");
50 if (!f) {
51 perror(cmd_file);
52 exit(1);
53 }
54 }
55 fflush(stdout);
56 fflush(stderr);
57 setbuf(stdout, NULL);
58 setbuf(stderr, NULL);
59 while (!feof(f)) {
60 if (fgets(buf, sizeof(buf), f) == NULL)
61 break;
62 if (buf[0] == '#')
63 continue;
64 noecho = 0;
65 if (buf[0] == '-') {
66 noecho = 1;
67 buf[0] = ' ';
68 }
69 cp = strchr(buf, '\n');
70 if (cp)
71 *cp = 0;
72 cp = strchr(buf, '\r');
73 if (cp)
74 *cp = 0;
75 if (!noecho)
76 printf("%s: %s\n", subsystem_name, buf);
77 retval = ss_execute_line(sci_idx, buf);
78 if (retval) {
79 ss_perror(sci_idx, retval, buf);
80 exit_status++;
81 }
82 }
83 return exit_status;
84 }
85
86
87 /*
88 * This function resets the libc getopt() function, which keeps
89 * internal state. Bad design! Stupid libc API designers! No
90 * biscuit!
91 *
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().
100 *
101 * More modern versions of BSD require that optreset be set to 1 in
102 * order to reset getopt(). Sigh. Standards, anyone?
103 *
104 * We hide the hair here.
105 */
reset_getopt(void)106 void reset_getopt(void)
107 {
108 #if defined(__GLIBC__) || defined(__linux__)
109 optind = 0;
110 #else
111 optind = 1;
112 #endif
113 #ifdef HAVE_OPTRESET
114 optreset = 1; /* Makes BSD getopt happy */
115 #endif
116 }
117
118 /*
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.
121 */
parse_ulong(const char * str,const char * cmd,const char * descr,int * err)122 unsigned long parse_ulong(const char *str, const char *cmd,
123 const char *descr, int *err)
124 {
125 char *tmp;
126 unsigned long ret;
127
128 ret = strtoul(str, &tmp, 0);
129 if (*tmp == 0) {
130 if (err)
131 *err = 0;
132 return ret;
133 }
134 com_err(cmd, 0, "Bad %s - %s", descr, str);
135 if (err)
136 *err = 1;
137 else
138 exit(1);
139 return 0;
140 }
141
142
check_fs_open(char * name)143 int check_fs_open(char *name)
144 {
145 if (!test_fs) {
146 com_err(name, 0, "Filesystem not open");
147 return 1;
148 }
149 return 0;
150 }
151
setup_filesystem(const char * name,unsigned int blocks,unsigned int inodes,unsigned int type,int flags)152 static void setup_filesystem(const char *name,
153 unsigned int blocks, unsigned int inodes,
154 unsigned int type, int flags)
155 {
156 struct ext2_super_block param;
157 errcode_t retval;
158
159 memset(¶m, 0, sizeof(param));
160 ext2fs_blocks_count_set(¶m, blocks);
161 param.s_inodes_count = inodes;
162
163 retval = ext2fs_initialize("test fs", flags, ¶m,
164 test_io_manager, &test_fs);
165
166 if (retval) {
167 com_err(name, retval, "while initializing filesystem");
168 return;
169 }
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);
177 if (retval) {
178 com_err(name, retval, "while allocating block bitmap");
179 goto errout;
180 }
181 retval = ext2fs_allocate_inode_bitmap(test_fs, "inode bitmap",
182 &test_fs->inode_map);
183 if (retval) {
184 com_err(name, retval, "while allocating inode bitmap");
185 goto errout;
186 }
187 return;
188
189 errout:
190 ext2fs_close_free(&test_fs);
191 }
192
setup_cmd(int argc,char ** argv)193 void setup_cmd(int argc, char **argv)
194 {
195 int c, err;
196 unsigned int blocks = 128;
197 unsigned int inodes = 0;
198 unsigned int type = EXT2FS_BMAP64_BITARRAY;
199 int flags = EXT2_FLAG_64BITS;
200
201 if (test_fs)
202 ext2fs_close_free(&test_fs);
203
204 reset_getopt();
205 while ((c = getopt(argc, argv, "b:i:lt:")) != EOF) {
206 switch (c) {
207 case 'b':
208 blocks = parse_ulong(optarg, argv[0],
209 "number of blocks", &err);
210 if (err)
211 return;
212 break;
213 case 'i':
214 inodes = parse_ulong(optarg, argv[0],
215 "number of blocks", &err);
216 if (err)
217 return;
218 break;
219 case 'l': /* Legacy bitmaps */
220 flags = 0;
221 break;
222 case 't':
223 type = parse_ulong(optarg, argv[0],
224 "bitmap backend type", &err);
225 if (err)
226 return;
227 break;
228 default:
229 fprintf(stderr, "%s: usage: setup [-b blocks] "
230 "[-i inodes] [-t type]\n", argv[0]);
231 return;
232 }
233 }
234 setup_filesystem(argv[0], blocks, inodes, type, flags);
235 }
236
close_cmd(int argc,char ** argv)237 void close_cmd(int argc, char **argv)
238 {
239 if (check_fs_open(argv[0]))
240 return;
241
242 ext2fs_close_free(&test_fs);
243 }
244
245
dump_bitmap(ext2fs_generic_bitmap bmap,unsigned int start,unsigned num)246 void dump_bitmap(ext2fs_generic_bitmap bmap, unsigned int start, unsigned num)
247 {
248 unsigned char *buf;
249 errcode_t retval;
250 int i, len = (num - start + 7) / 8;
251
252 buf = malloc(len);
253 if (!buf) {
254 com_err("dump_bitmap", 0, "couldn't allocate buffer");
255 return;
256 }
257 memset(buf, 0, len);
258 retval = ext2fs_get_generic_bmap_range(bmap, (__u64) start, num, buf);
259 if (retval) {
260 com_err("dump_bitmap", retval,
261 "while calling ext2fs_generic_bmap_range");
262 free(buf);
263 return;
264 }
265 for (i=0; i < len; i++)
266 printf("%02x", buf[i]);
267 printf("\n");
268 printf("bits set: %u\n", ext2fs_bitcount(buf, len));
269 free(buf);
270 }
271
dump_inode_bitmap_cmd(int argc,char ** argv)272 void dump_inode_bitmap_cmd(int argc, char **argv)
273 {
274 if (check_fs_open(argv[0]))
275 return;
276
277 printf("inode bitmap: ");
278 dump_bitmap(test_fs->inode_map, 1, test_fs->super->s_inodes_count);
279 }
280
dump_block_bitmap_cmd(int argc,char ** argv)281 void dump_block_bitmap_cmd(int argc, char **argv)
282 {
283 if (check_fs_open(argv[0]))
284 return;
285
286 printf("block bitmap: ");
287 dump_bitmap(test_fs->block_map, test_fs->super->s_first_data_block,
288 test_fs->super->s_blocks_count);
289 }
290
do_setb(int argc,char * argv[])291 void do_setb(int argc, char *argv[])
292 {
293 unsigned int block, num;
294 int err;
295 int test_result, op_result;
296
297 if (check_fs_open(argv[0]))
298 return;
299
300 if (argc != 2 && argc != 3) {
301 com_err(argv[0], 0, "Usage: setb <block> [num]");
302 return;
303 }
304
305 block = parse_ulong(argv[1], argv[0], "block", &err);
306 if (err)
307 return;
308
309 if (argc == 3) {
310 num = parse_ulong(argv[2], argv[0], "num", &err);
311 if (err)
312 return;
313
314 ext2fs_mark_block_bitmap_range2(test_fs->block_map,
315 block, num);
316 printf("Marking blocks %u to %u\n", block, block + num - 1);
317 return;
318 }
319
320 test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
321 op_result = ext2fs_mark_block_bitmap2(test_fs->block_map, block);
322 printf("Setting block %u, was %s before\n", block, op_result ?
323 "set" : "clear");
324 if (!test_result != !op_result)
325 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
326 test_result, op_result);
327 }
328
do_clearb(int argc,char * argv[])329 void do_clearb(int argc, char *argv[])
330 {
331 unsigned int block, num;
332 int err;
333 int test_result, op_result;
334
335 if (check_fs_open(argv[0]))
336 return;
337
338 if (argc != 2 && argc != 3) {
339 com_err(argv[0], 0, "Usage: clearb <block> [num]");
340 return;
341 }
342
343 block = parse_ulong(argv[1], argv[0], "block", &err);
344 if (err)
345 return;
346
347 if (argc == 3) {
348 num = parse_ulong(argv[2], argv[0], "num", &err);
349 if (err)
350 return;
351
352 ext2fs_unmark_block_bitmap_range2(test_fs->block_map,
353 block, num);
354 printf("Clearing blocks %u to %u\n", block, block + num - 1);
355 return;
356 }
357
358 test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
359 op_result = ext2fs_unmark_block_bitmap2(test_fs->block_map, block);
360 printf("Clearing block %u, was %s before\n", block, op_result ?
361 "set" : "clear");
362 if (!test_result != !op_result)
363 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
364 test_result, op_result);
365 }
366
do_testb(int argc,char * argv[])367 void do_testb(int argc, char *argv[])
368 {
369 unsigned int block, num;
370 int err;
371 int test_result;
372
373 if (check_fs_open(argv[0]))
374 return;
375
376 if (argc != 2 && argc != 3) {
377 com_err(argv[0], 0, "Usage: testb <block> [num]");
378 return;
379 }
380
381 block = parse_ulong(argv[1], argv[0], "block", &err);
382 if (err)
383 return;
384
385 if (argc == 3) {
386 num = parse_ulong(argv[2], argv[0], "num", &err);
387 if (err)
388 return;
389
390 test_result =
391 ext2fs_test_block_bitmap_range2(test_fs->block_map,
392 block, num);
393 printf("Blocks %u to %u are %sall clear.\n",
394 block, block + num - 1, test_result ? "" : "NOT ");
395 return;
396 }
397
398 test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
399 printf("Block %u is %s\n", block, test_result ? "set" : "clear");
400 }
401
do_ffzb(int argc,char * argv[])402 void do_ffzb(int argc, char *argv[])
403 {
404 unsigned int start, end;
405 int err;
406 errcode_t retval;
407 blk64_t out;
408
409 if (check_fs_open(argv[0]))
410 return;
411
412 if (argc != 3 && argc != 3) {
413 com_err(argv[0], 0, "Usage: ffzb <start> <end>");
414 return;
415 }
416
417 start = parse_ulong(argv[1], argv[0], "start", &err);
418 if (err)
419 return;
420
421 end = parse_ulong(argv[2], argv[0], "end", &err);
422 if (err)
423 return;
424
425 retval = ext2fs_find_first_zero_block_bitmap2(test_fs->block_map,
426 start, end, &out);
427 if (retval) {
428 printf("ext2fs_find_first_zero_block_bitmap2() returned %s\n",
429 error_message(retval));
430 return;
431 }
432 printf("First unmarked block is %llu\n", out);
433 }
434
do_ffsb(int argc,char * argv[])435 void do_ffsb(int argc, char *argv[])
436 {
437 unsigned int start, end;
438 int err;
439 errcode_t retval;
440 blk64_t out;
441
442 if (check_fs_open(argv[0]))
443 return;
444
445 if (argc != 3 && argc != 3) {
446 com_err(argv[0], 0, "Usage: ffsb <start> <end>");
447 return;
448 }
449
450 start = parse_ulong(argv[1], argv[0], "start", &err);
451 if (err)
452 return;
453
454 end = parse_ulong(argv[2], argv[0], "end", &err);
455 if (err)
456 return;
457
458 retval = ext2fs_find_first_set_block_bitmap2(test_fs->block_map,
459 start, end, &out);
460 if (retval) {
461 printf("ext2fs_find_first_set_block_bitmap2() returned %s\n",
462 error_message(retval));
463 return;
464 }
465 printf("First marked block is %llu\n", out);
466 }
467
468
do_zerob(int argc,char * argv[])469 void do_zerob(int argc, char *argv[])
470 {
471 if (check_fs_open(argv[0]))
472 return;
473
474 printf("Clearing block bitmap.\n");
475 ext2fs_clear_block_bitmap(test_fs->block_map);
476 }
477
do_seti(int argc,char * argv[])478 void do_seti(int argc, char *argv[])
479 {
480 unsigned int inode;
481 int err;
482 int test_result, op_result;
483
484 if (check_fs_open(argv[0]))
485 return;
486
487 if (argc != 2) {
488 com_err(argv[0], 0, "Usage: seti <inode>");
489 return;
490 }
491
492 inode = parse_ulong(argv[1], argv[0], "inode", &err);
493 if (err)
494 return;
495
496 test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
497 op_result = ext2fs_mark_inode_bitmap2(test_fs->inode_map, inode);
498 printf("Setting inode %u, was %s before\n", inode, op_result ?
499 "set" : "clear");
500 if (!test_result != !op_result) {
501 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
502 test_result, op_result);
503 exit_status++;
504 }
505 }
506
do_cleari(int argc,char * argv[])507 void do_cleari(int argc, char *argv[])
508 {
509 unsigned int inode;
510 int err;
511 int test_result, op_result;
512
513 if (check_fs_open(argv[0]))
514 return;
515
516 if (argc != 2) {
517 com_err(argv[0], 0, "Usage: clearb <inode>");
518 return;
519 }
520
521 inode = parse_ulong(argv[1], argv[0], "inode", &err);
522 if (err)
523 return;
524
525 test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
526 op_result = ext2fs_unmark_inode_bitmap2(test_fs->inode_map, inode);
527 printf("Clearing inode %u, was %s before\n", inode, op_result ?
528 "set" : "clear");
529 if (!test_result != !op_result) {
530 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
531 test_result, op_result);
532 exit_status++;
533 }
534 }
535
do_testi(int argc,char * argv[])536 void do_testi(int argc, char *argv[])
537 {
538 unsigned int inode;
539 int err;
540 int test_result;
541
542 if (check_fs_open(argv[0]))
543 return;
544
545 if (argc != 2) {
546 com_err(argv[0], 0, "Usage: testb <inode>");
547 return;
548 }
549
550 inode = parse_ulong(argv[1], argv[0], "inode", &err);
551 if (err)
552 return;
553
554 test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
555 printf("Inode %u is %s\n", inode, test_result ? "set" : "clear");
556 }
557
do_ffzi(int argc,char * argv[])558 void do_ffzi(int argc, char *argv[])
559 {
560 unsigned int start, end;
561 int err;
562 errcode_t retval;
563 ext2_ino_t out;
564
565 if (check_fs_open(argv[0]))
566 return;
567
568 if (argc != 3 && argc != 3) {
569 com_err(argv[0], 0, "Usage: ffzi <start> <end>");
570 return;
571 }
572
573 start = parse_ulong(argv[1], argv[0], "start", &err);
574 if (err)
575 return;
576
577 end = parse_ulong(argv[2], argv[0], "end", &err);
578 if (err)
579 return;
580
581 retval = ext2fs_find_first_zero_inode_bitmap2(test_fs->inode_map,
582 start, end, &out);
583 if (retval) {
584 printf("ext2fs_find_first_zero_inode_bitmap2() returned %s\n",
585 error_message(retval));
586 return;
587 }
588 printf("First unmarked inode is %u\n", out);
589 }
590
do_ffsi(int argc,char * argv[])591 void do_ffsi(int argc, char *argv[])
592 {
593 unsigned int start, end;
594 int err;
595 errcode_t retval;
596 ext2_ino_t out;
597
598 if (check_fs_open(argv[0]))
599 return;
600
601 if (argc != 3 && argc != 3) {
602 com_err(argv[0], 0, "Usage: ffsi <start> <end>");
603 return;
604 }
605
606 start = parse_ulong(argv[1], argv[0], "start", &err);
607 if (err)
608 return;
609
610 end = parse_ulong(argv[2], argv[0], "end", &err);
611 if (err)
612 return;
613
614 retval = ext2fs_find_first_set_inode_bitmap2(test_fs->inode_map,
615 start, end, &out);
616 if (retval) {
617 printf("ext2fs_find_first_set_inode_bitmap2() returned %s\n",
618 error_message(retval));
619 return;
620 }
621 printf("First marked inode is %u\n", out);
622 }
623
do_zeroi(int argc,char * argv[])624 void do_zeroi(int argc, char *argv[])
625 {
626 if (check_fs_open(argv[0]))
627 return;
628
629 printf("Clearing inode bitmap.\n");
630 ext2fs_clear_inode_bitmap(test_fs->inode_map);
631 }
632
main(int argc,char ** argv)633 int main(int argc, char **argv)
634 {
635 unsigned int blocks = 128;
636 unsigned int inodes = 0;
637 unsigned int type = EXT2FS_BMAP64_BITARRAY;
638 int c, err, code;
639 char *request = (char *)NULL;
640 char *cmd_file = 0;
641 int sci_idx;
642 int flags = EXT2_FLAG_64BITS;
643
644 add_error_table(&et_ss_error_table);
645 add_error_table(&et_ext2_error_table);
646 while ((c = getopt (argc, argv, "b:i:lt:R:f:")) != EOF) {
647 switch (c) {
648 case 'b':
649 blocks = parse_ulong(optarg, argv[0],
650 "number of blocks", &err);
651 if (err)
652 exit(1);
653 break;
654 case 'i':
655 inodes = parse_ulong(optarg, argv[0],
656 "number of blocks", &err);
657 if (err)
658 exit(1);
659 break;
660 case 'l': /* Legacy bitmaps */
661 flags = 0;
662 break;
663 case 't':
664 type = parse_ulong(optarg, argv[0],
665 "bitmap backend type", &err);
666 if (err)
667 exit(1);
668 break;
669 case 'R':
670 request = optarg;
671 break;
672 case 'f':
673 cmd_file = optarg;
674 break;
675 default:
676 com_err(argv[0], 0, "Usage: %s [-R request] "
677 "[-f cmd_file]", subsystem_name);
678 exit(1);
679 }
680 }
681
682 sci_idx = ss_create_invocation(subsystem_name, version,
683 (char *)NULL, &tst_bitmaps_cmds, &code);
684 if (code) {
685 ss_perror(sci_idx, code, "creating invocation");
686 exit(1);
687 }
688
689 (void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &code);
690 if (code) {
691 ss_perror(sci_idx, code, "adding standard requests");
692 exit (1);
693 }
694
695 printf("%s %s. Type '?' for a list of commands.\n\n",
696 subsystem_name, version);
697
698 setup_filesystem(argv[0], blocks, inodes, type, flags);
699
700 if (request) {
701 code = ss_execute_line(sci_idx, request);
702 if (code) {
703 ss_perror(sci_idx, code, request);
704 exit_status++;
705 }
706 } else if (cmd_file) {
707 exit_status = source_file(cmd_file, sci_idx);
708 } else {
709 ss_listen(sci_idx);
710 }
711
712 exit(exit_status);
713 }
714
715