int main (int argc, char ** argv) { errcode_t retval; ext2_filsys fs; io_manager io_ptr; initialize_ext2_error_table(); blkid_get_cache(&cache, NULL); PRS(argc, argv); #ifdef CONFIG_TESTIO_DEBUG io_ptr = test_io_manager; test_io_backing_manager = unix_io_manager; #else io_ptr = unix_io_manager; #endif retval = ext2fs_open (device_name, open_flag, 0, 0, io_ptr, &fs); if (retval) exit(1); if (root_type) get_root_type(fs); return (ext2fs_close (fs) ? 1 : 0); }
int main(int argc, char *argv[]) { char *ptr; if (NULL != (ptr = strrchr(argv[0], '/'))) ptr++; else ptr = argv[0]; if (strcmp(ptr, "e2tools") == 0) { if (argc < 2) { usage(); exit(1); } ++argv; --argc; ptr = argv[0]; } initialize_ext2_error_table(); if (strcmp(ptr, "e2ls") == 0) exit(do_list_dir(argc, argv)); else if (strcmp(ptr, "e2cp") == 0) exit(copy(argc, argv)); else if (strcmp(ptr, "e2mkdir") == 0) exit(e2mkdir(argc, argv)); else if (strcmp(ptr, "e2ln") == 0) exit(do_ln(argc, argv)); else if (strcmp(ptr, "e2mv") == 0) exit(do_mv(argc, argv)); else if (strcmp(ptr, "e2rm") == 0) exit(e2rm(argc, argv)); else if (strcmp(ptr, "e2tail") == 0) exit(do_tail(argc, argv)); else { fprintf(stderr, "Not implemented\n"); exit(1); } return(0); }
static void PRS(int argc, char *argv[]) { int flush = 0; int c; #ifdef MTRACE extern void *mallwatch; #endif errcode_t retval; setbuf(stdout, NULL); setbuf(stderr, NULL); initialize_ext2_error_table(); if (argc && *argv) program_name = *argv; while ((c = getopt (argc, argv, "FI")) != EOF) switch (c) { case 'F': flush = 1; break; case 'I': inode_buffer_blocks = atoi(optarg); break; default: usage (); } device_name = argv[optind]; if (flush) { int fd = open(device_name, O_RDONLY, 0); if (fd < 0) { com_err("open", errno, _("while opening %s for flushing"), device_name); exit(FSCK_ERROR); } if ((retval = ext2fs_sync_device(fd, 1))) { com_err("ext2fs_sync_device", retval, _("while trying to flush %s"), device_name); exit(FSCK_ERROR); } close(fd); } }
/* * Setup the variables for doing the inode scan test. */ static void setup(void) { errcode_t retval; struct ext2_super_block param; initialize_ext2_error_table(); memset(¶m, 0, sizeof(param)); ext2fs_blocks_count_set(¶m, 12000); retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m, test_io_manager, &test_fs); if (retval) { com_err("setup", retval, "while initializing filesystem"); exit(1); } retval = ext2fs_allocate_tables(test_fs); if (retval) { com_err("setup", retval, "while allocating tables for test filesystem"); exit(1); } }
static void PRS(int argc, char *argv[]) { int b, c; int size; char *tmp, *tmp2; int blocksize = 0; int inode_ratio = 0; int inode_size = 0; double reserved_ratio = 5.0; int sector_size = 0; int show_version_only = 0; ext2_ino_t num_inodes = 0; errcode_t retval; char * oldpath = getenv("PATH"); char * extended_opts = 0; const char * fs_type = 0; blk_t dev_size; #ifdef __linux__ struct utsname ut; #endif long sysval; int s_opt = -1, r_opt = -1; char *fs_features = 0; int use_bsize; /* Update our PATH to include /sbin */ if (oldpath) { char *newpath; newpath = malloc(sizeof (PATH_SET) + 1 + strlen (oldpath)); strcpy (newpath, PATH_SET); strcat (newpath, ":"); strcat (newpath, oldpath); putenv (newpath); } else putenv (PATH_SET); tmp = getenv("MKE2FS_SYNC"); if (tmp) sync_kludge = atoi(tmp); /* Determine the system page size if possible */ #ifdef HAVE_SYSCONF #if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE)) #define _SC_PAGESIZE _SC_PAGE_SIZE #endif #ifdef _SC_PAGESIZE sysval = sysconf(_SC_PAGESIZE); if (sysval > 0) sys_page_size = sysval; #endif /* _SC_PAGESIZE */ #endif /* HAVE_SYSCONF */ if ((tmp = getenv("MKE2FS_CONFIG")) != NULL) config_fn[0] = tmp; profile_set_syntax_err_cb(syntax_err_report); profile_init(config_fn, &profile); setbuf(stdout, NULL); setbuf(stderr, NULL); initialize_ext2_error_table(); memset(&fs_param, 0, sizeof(struct ext2_super_block)); fs_param.s_rev_level = 1; /* Create revision 1 filesystems now */ #ifdef __linux__ if (uname(&ut)) { perror("uname"); exit(1); } linux_version_code = parse_version_number(ut.release); if (linux_version_code && linux_version_code < (2*65536 + 2*256)) fs_param.s_rev_level = 0; #endif if (argc && *argv) { program_name = get_progname(*argv); /* If called as mkfs.ext3, create a journal inode */ if (!strcmp(program_name, "mkfs.ext3")) journal_size = -1; } while ((c = getopt (argc, argv, "b:cf:g:i:jl:m:no:qr:s:tvE:FI:J:L:M:N:O:R:ST:V")) != EOF) { switch (c) { case 'b': blocksize = strtol(optarg, &tmp, 0); b = (blocksize > 0) ? blocksize : -blocksize; if (b < EXT2_MIN_BLOCK_SIZE || b > EXT2_MAX_BLOCK_SIZE || *tmp) { com_err(program_name, 0, _("invalid block size - %s"), optarg); exit(1); } if (blocksize > 4096) fprintf(stderr, _("Warning: blocksize %d not " "usable on most systems.\n"), blocksize); if (blocksize > 0) fs_param.s_log_block_size = int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE); break; case 'c': /* Check for bad blocks */ case 't': /* deprecated */ cflag++; break; case 'f': size = strtoul(optarg, &tmp, 0); if (size < EXT2_MIN_BLOCK_SIZE || size > EXT2_MAX_BLOCK_SIZE || *tmp) { com_err(program_name, 0, _("invalid fragment size - %s"), optarg); exit(1); } fs_param.s_log_frag_size = int_log2(size >> EXT2_MIN_BLOCK_LOG_SIZE); fprintf(stderr, _("Warning: fragments not supported. " "Ignoring -f option\n")); break; case 'g': fs_param.s_blocks_per_group = strtoul(optarg, &tmp, 0); if (*tmp) { com_err(program_name, 0, _("Illegal number for blocks per group")); exit(1); } if ((fs_param.s_blocks_per_group % 8) != 0) { com_err(program_name, 0, _("blocks per group must be multiple of 8")); exit(1); } break; case 'i': inode_ratio = strtoul(optarg, &tmp, 0); if (inode_ratio < EXT2_MIN_BLOCK_SIZE || inode_ratio > EXT2_MAX_BLOCK_SIZE * 1024 || *tmp) { com_err(program_name, 0, _("invalid inode ratio %s (min %d/max %d)"), optarg, EXT2_MIN_BLOCK_SIZE, EXT2_MAX_BLOCK_SIZE); exit(1); } break; case 'J': parse_journal_opts(optarg); break; case 'j': if (!journal_size) journal_size = -1; break; case 'l': bad_blocks_filename = malloc(strlen(optarg)+1); if (!bad_blocks_filename) { com_err(program_name, ENOMEM, _("in malloc for bad_blocks_filename")); exit(1); } strcpy(bad_blocks_filename, optarg); break; case 'm': reserved_ratio = strtod(optarg, &tmp); if (reserved_ratio > 50 || *tmp) { com_err(program_name, 0, _("invalid reserved blocks percent - %s"), optarg); exit(1); } break; case 'n': noaction++; break; case 'o': creator_os = optarg; break; case 'q': quiet = 1; break; case 'r': r_opt = strtoul(optarg, &tmp, 0); if (*tmp) { com_err(program_name, 0, _("bad revision level - %s"), optarg); exit(1); } fs_param.s_rev_level = r_opt; break; case 's': /* deprecated */ s_opt = atoi(optarg); break; #ifdef EXT2_DYNAMIC_REV case 'I': inode_size = strtoul(optarg, &tmp, 0); if (*tmp) { com_err(program_name, 0, _("invalid inode size - %s"), optarg); exit(1); } break; #endif case 'v': verbose = 1; break; case 'F': force = 1; break; case 'L': volume_label = optarg; break; case 'M': mount_dir = optarg; break; case 'N': num_inodes = strtoul(optarg, &tmp, 0); if (*tmp) { com_err(program_name, 0, _("bad num inodes - %s"), optarg); exit(1); } break; case 'O': fs_features = optarg; break; case 'E': case 'R': extended_opts = optarg; break; case 'S': super_only = 1; break; case 'T': fs_type = optarg; break; case 'V': /* Print version number and exit */ show_version_only++; break; default: usage(); } } if ((optind == argc) && !show_version_only) usage(); device_name = argv[optind++]; if (!quiet || show_version_only) fprintf (stderr, "mke2fs %s (%s)\n", E2FSPROGS_VERSION, E2FSPROGS_DATE); if (show_version_only) { fprintf(stderr, _("\tUsing %s\n"), error_message(EXT2_ET_BASE)); exit(0); } /* * If there's no blocksize specified and there is a journal * device, use it to figure out the blocksize */ if (blocksize <= 0 && journal_device) { ext2_filsys jfs; io_manager io_ptr; #ifdef CONFIG_TESTIO_DEBUG io_ptr = test_io_manager; test_io_backing_manager = unix_io_manager; #else io_ptr = unix_io_manager; #endif retval = ext2fs_open(journal_device, EXT2_FLAG_JOURNAL_DEV_OK, 0, 0, io_ptr, &jfs); if (retval) { com_err(program_name, retval, _("while trying to open journal device %s\n"), journal_device); exit(1); } if ((blocksize < 0) && (jfs->blocksize < (unsigned) (-blocksize))) { com_err(program_name, 0, _("Journal dev blocksize (%d) smaller than " "minimum blocksize %d\n"), jfs->blocksize, -blocksize); exit(1); } blocksize = jfs->blocksize; fs_param.s_log_block_size = int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE); ext2fs_close(jfs); }
int main(int argc, char **argv) { int retval; int sci_idx; int c; char *request = 0; int exit_status = 0; char *cmd_file = 0; struct ext2_super_block param; initialize_ext2_error_table(); /* * Create a sample filesystem structure */ memset(¶m, 0, sizeof(struct ext2_super_block)); ext2fs_blocks_count_set(¶m, 80000); param.s_inodes_count = 20000; retval = ext2fs_initialize("/dev/null", 0, ¶m, unix_io_manager, &test_fs); if (retval) { com_err("/dev/null", retval, "while setting up test fs"); exit(1); } while ((c = getopt (argc, argv, "wR:f:")) != EOF) { switch (c) { case 'R': request = optarg; break; case 'f': cmd_file = optarg; break; default: com_err(argv[0], 0, "Usage: test_icount " "[-R request] [-f cmd_file]"); exit(1); } } sci_idx = ss_create_invocation("test_icount", "0.0", (char *) NULL, &test_cmds, &retval); if (retval) { ss_perror(sci_idx, retval, "creating invocation"); exit(1); } (void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &retval); if (retval) { ss_perror(sci_idx, retval, "adding standard requests"); exit (1); } if (request) { retval = 0; retval = ss_execute_line(sci_idx, request); if (retval) { ss_perror(sci_idx, retval, request); exit_status++; } } else if (cmd_file) { exit_status = source_file(cmd_file, sci_idx); } else { ss_listen(sci_idx); } return(exit_status); }
int main(int argc, char *argv[]) { ext2_filsys fs; struct ext2_super_block param; errcode_t retval; int i; /* setup */ initialize_ext2_error_table(); memset(¶m, 0, sizeof(param)); ext2fs_blocks_count_set(¶m, 32768); param.s_inodes_count = 100; param.s_feature_incompat |= EXT4_FEATURE_INCOMPAT_INLINE_DATA; param.s_rev_level = EXT2_DYNAMIC_REV; param.s_inode_size = 256; retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m, test_io_manager, &fs); if (retval) { com_err("setup", retval, "while initializing filesystem"); exit(1); } retval = ext2fs_allocate_tables(fs); if (retval) { com_err("setup", retval, "while allocating tables for test filesysmte"); exit(1); } /* initialize inode cache */ if (!fs->icache) { struct ext2_inode inode; ext2_ino_t first_ino = EXT2_FIRST_INO(fs->super); int i; /* we just want to init inode cache. So ignore error */ ext2fs_create_inode_cache(fs, 16); if (!fs->icache) { fprintf(stderr, "tst_inline_data: init inode cache failed\n"); exit(1); } /* setup inode cache */ for (i = 0; i < fs->icache->cache_size; i++) fs->icache->cache[i].ino = first_ino++; } /* test */ if (file_test(fs)) { fprintf(stderr, "tst_inline_data(FILE): FAILED\n"); return 1; } printf("tst_inline_data(FILE): OK\n"); if (dir_test(fs)) { fprintf(stderr, "tst_inline_data(DIR): FAILED\n"); return 1; } printf("tst_inline_data(DIR): OK\n"); return 0; }
static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) { int flush = 0; int c, fd; #ifdef MTRACE extern void *mallwatch; #endif e2fsck_t ctx; errcode_t retval; #ifdef HAVE_SIGNAL_H struct sigaction sa; #endif char *extended_opts = 0; char *cp; retval = e2fsck_allocate_context(&ctx); if (retval) return retval; *ret_ctx = ctx; setvbuf(stdout, NULL, _IONBF, BUFSIZ); setvbuf(stderr, NULL, _IONBF, BUFSIZ); if (isatty(0) && isatty(1)) { ctx->interactive = 1; } else { ctx->start_meta[0] = '\001'; ctx->stop_meta[0] = '\002'; } memset(bar, '=', sizeof(bar)-1); memset(spaces, ' ', sizeof(spaces)-1); initialize_ext2_error_table(); initialize_prof_error_table(); blkid_get_cache(&ctx->blkid, NULL); if (argc && *argv) ctx->program_name = *argv; else ctx->program_name = "e2fsck"; while ((c = getopt (argc, argv, "panyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDk")) != EOF) switch (c) { case 'C': ctx->progress = e2fsck_update_progress; ctx->progress_fd = atoi(optarg); if (!ctx->progress_fd) break; /* Validate the file descriptor to avoid disasters */ fd = dup(ctx->progress_fd); if (fd < 0) { fprintf(stderr, _("Error validating file descriptor %d: %s\n"), ctx->progress_fd, error_message(errno)); fatal_error(ctx, _("Invalid completion information file descriptor")); } else close(fd); break; case 'D': ctx->options |= E2F_OPT_COMPRESS_DIRS; break; case 'E': extended_opts = optarg; break; case 'p': case 'a': if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) { conflict_opt: fatal_error(ctx, _("Only one of the options -p/-a, -n or -y may be specified.")); } ctx->options |= E2F_OPT_PREEN; break; case 'n': if (ctx->options & (E2F_OPT_YES|E2F_OPT_PREEN)) goto conflict_opt; ctx->options |= E2F_OPT_NO; break; case 'y': if (ctx->options & (E2F_OPT_PREEN|E2F_OPT_NO)) goto conflict_opt; ctx->options |= E2F_OPT_YES; break; case 't': #ifdef RESOURCE_TRACK if (ctx->options & E2F_OPT_TIME) ctx->options |= E2F_OPT_TIME2; else ctx->options |= E2F_OPT_TIME; #else fprintf(stderr, _("The -t option is not " "supported on this version of e2fsck.\n")); #endif break; case 'c': if (cflag++) ctx->options |= E2F_OPT_WRITECHECK; ctx->options |= E2F_OPT_CHECKBLOCKS; break; case 'r': /* What we do by default, anyway! */ break; case 'b': ctx->use_superblock = atoi(optarg); ctx->flags |= E2F_FLAG_SB_SPECIFIED; break; case 'B': ctx->blocksize = atoi(optarg); break; case 'I': ctx->inode_buffer_blocks = atoi(optarg); break; case 'j': ctx->journal_name = string_copy(ctx, optarg, 0); break; case 'P': ctx->process_inode_size = atoi(optarg); break; case 'L': replace_bad_blocks++; case 'l': bad_blocks_file = string_copy(ctx, optarg, 0); break; case 'd': ctx->options |= E2F_OPT_DEBUG; break; case 'f': ctx->options |= E2F_OPT_FORCE; break; case 'F': flush = 1; break; case 'v': verbose = 1; break; case 'V': show_version_only = 1; break; #ifdef MTRACE case 'M': mallwatch = (void *) strtol(optarg, NULL, 0); break; #endif case 'N': ctx->device_name = optarg; break; #ifdef ENABLE_SWAPFS case 's': normalize_swapfs = 1; case 'S': swapfs = 1; break; #else case 's': case 'S': fprintf(stderr, _("Byte-swapping filesystems " "not compiled in this version " "of e2fsck\n")); exit(1); #endif case 'k': keep_bad_blocks++; break; default: usage(ctx); } if (show_version_only) return 0; if (optind != argc - 1) usage(ctx); if ((ctx->options & E2F_OPT_NO) && !bad_blocks_file && !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS)) ctx->options |= E2F_OPT_READONLY; ctx->io_options = strchr(argv[optind], '?'); if (ctx->io_options) *ctx->io_options++ = 0; ctx->filesystem_name = blkid_get_devname(ctx->blkid, argv[optind], 0); if (!ctx->filesystem_name) { com_err(ctx->program_name, 0, _("Unable to resolve '%s'"), argv[optind]); fatal_error(ctx, 0); } if (extended_opts) parse_extended_opts(ctx, extended_opts); if ((cp = getenv("E2FSCK_CONFIG")) != NULL) config_fn[0] = cp; profile_set_syntax_err_cb(syntax_err_report); profile_init(config_fn, &ctx->profile); if (flush) { fd = open(ctx->filesystem_name, O_RDONLY, 0); if (fd < 0) { com_err("open", errno, _("while opening %s for flushing"), ctx->filesystem_name); fatal_error(ctx, 0); } if ((retval = ext2fs_sync_device(fd, 1))) { com_err("ext2fs_sync_device", retval, _("while trying to flush %s"), ctx->filesystem_name); fatal_error(ctx, 0); } close(fd); } #ifdef ENABLE_SWAPFS if (swapfs) { if (cflag || bad_blocks_file) { fprintf(stderr, _("Incompatible options not " "allowed when byte-swapping.\n")); exit(FSCK_USAGE); } } #endif if (cflag && bad_blocks_file) { fprintf(stderr, _("The -c and the -l/-L options may " "not be both used at the same time.\n")); exit(FSCK_USAGE); } #ifdef HAVE_SIGNAL_H /* * Set up signal action */ memset(&sa, 0, sizeof(struct sigaction)); sa.sa_handler = signal_cancel; sigaction(SIGINT, &sa, 0); sigaction(SIGTERM, &sa, 0); #ifdef SA_RESTART sa.sa_flags = SA_RESTART; #endif e2fsck_global_ctx = ctx; sa.sa_handler = signal_progress_on; sigaction(SIGUSR1, &sa, 0); sa.sa_handler = signal_progress_off; sigaction(SIGUSR2, &sa, 0); #endif /* Update our PATH to include /sbin if we need to run badblocks */ if (cflag) { char *oldpath = getenv("PATH"); if (oldpath) { char *newpath; newpath = (char *) malloc(sizeof (PATH_SET) + 1 + strlen (oldpath)); if (!newpath) fatal_error(ctx, "Couldn't malloc() newpath"); strcpy (newpath, PATH_SET); strcat (newpath, ":"); strcat (newpath, oldpath); putenv (newpath); } else putenv (PATH_SET); } #ifdef CONFIG_JBD_DEBUG if (getenv("E2FSCK_JBD_DEBUG")) journal_enable_debug = atoi(getenv("E2FSCK_JBD_DEBUG")); #endif return 0; }
/* * Setup the variables for doing the inode scan test. */ static void setup(void) { errcode_t retval; int i; struct ext2_super_block param; initialize_ext2_error_table(); memset(¶m, 0, sizeof(param)); param.s_blocks_count = 12000; test_io_cb_read_blk = test_read_blk; retval = ext2fs_initialize("test fs", 0, ¶m, test_io_manager, &test_fs); if (retval) { com_err("setup", retval, "While initializing filesystem"); exit(1); } retval = ext2fs_allocate_tables(test_fs); if (retval) { com_err("setup", retval, "While allocating tables for test filesystem"); exit(1); } retval = ext2fs_allocate_block_bitmap(test_fs, "bad block map", &bad_block_map); if (retval) { com_err("setup", retval, "While allocating bad_block bitmap"); exit(1); } retval = ext2fs_allocate_block_bitmap(test_fs, "touched map", &touched_map); if (retval) { com_err("setup", retval, "While allocating touched block bitmap"); exit(1); } retval = ext2fs_allocate_inode_bitmap(test_fs, "bad inode map", &bad_inode_map); if (retval) { com_err("setup", retval, "While allocating bad inode bitmap"); exit(1); } retval = ext2fs_badblocks_list_create(&test_badblocks, 5); if (retval) { com_err("setup", retval, "while creating badblocks list"); exit(1); } for (i=0; test_vec[i]; i++) { retval = ext2fs_badblocks_list_add(test_badblocks, test_vec[i]); if (retval) { com_err("setup", retval, "while adding test vector %d", i); exit(1); } ext2fs_mark_block_bitmap(bad_block_map, test_vec[i]); } test_fs->badblocks = test_badblocks; }