int main(int argc, char *argv[]) { #if TRACKMEM mcheck(CheckFailed); #endif CSumItApplication app; app.Run(); gPrefs->WritePrefFile(); delete gPrefs; CFontStyle::Cleanup(); #if TRACKMEM FREE(gFuncs); FREE(gFuncArrayByName); FREE(gFuncDescriptions); FREE(gFuncPasteStrings); PrintUndisposed(); #endif return 0; }
/* =============== main =============== */ int main( int argc, const char** argv ) { // DG: needed for Sys_ReLaunch() cmdargc = argc; cmdargv = argv; // DG end #ifdef ID_MCHECK // must have -lmcheck linkage mcheck( abrt_func ); Sys_Printf( "memory consistency checking enabled\n" ); #endif Posix_EarlyInit( ); if( argc > 1 ) { common->Init( argc - 1, &argv[1], NULL ); } else { common->Init( 0, NULL, NULL ); } Posix_LateInit( ); while( 1 ) { common->Frame(); } }
int mcheck_pedantic (void (*func) (enum mcheck_status)) { int res = mcheck (func); if (res == 0) pedantic = 1; return res; }
list *list_create(int key, int score) { list *l = (list *) malloc(sizeof(list)); mcheck(l); l->key = key; l->score = score; l->tail = NULL; return l; }
/* * You can ask malloc to check the consistency of dynamic memory by using the mcheck function. * This function is a GNU extension, declared in mcheck.h. * Calling mcheck tells malloc to perform occasional consistency checks. These will catch things such as * writing past the end of a block that was allocated with malloc. * It is too late to begin allocation checking once you have allocated anything with malloc. * So mcheck does nothing in that case. The function returns -1 if you call it too late, * and 0 otherwise (when it is successful). * function prototype: mcheck (void (*abortfn) (enum mcheck_status status)) */ void FC_FUNC_(clib_mcheck,CLIB_MCHECK) (int* ierr) { #ifdef HAVE_MCHECK_H *ierr = mcheck (NULL); #else *ierr = 2; #endif }
static void s_once_proc(void) { char *a; uintptr_t b; #if 0 (void)mcheck(s_mcheck_proc); #endif a = (char *)malloc(10); b = (uintptr_t)sbrk((intptr_t)0); if (b <= (uintptr_t)&end || (uintptr_t)a >= b) { s_is_running_under_valgrind = true; } free((void *)a); }
int main() { mcheck(0); nz_rc rc = run(); if(rc != NZ_SUCCESS) { fprintf(stderr, "Noise error %d: %s\n", rc, nz_error_rc_str(rc)); fprintf(stderr, "File: %s line %d\n", nz_error_file, nz_error_line); if(nz_error_string) { fprintf(stderr, "%s\n", nz_error_string); nz_free_str(nz_error_string); } return 1; } return 0; }
/* =============== main =============== */ int main( int argc, const char **argv ) { #ifdef ID_MCHECK // must have -lmcheck linkage mcheck( abrt_func ); Sys_Printf( "memory consistency checking enabled\n" ); #endif Posix_EarlyInit( ); if( argc > 1 ) { common->Init( argc - 1, &argv[1], NULL ); } else { common->Init( 0, NULL, NULL ); } Posix_LateInit( ); while( true ) { common->Frame(); } }
int main (void) { int * table_int; int i; if (mcheck (fonction_d_erreur) != 0) { perror ("mcheck"); exit (1); } fprintf (stdout, "Allocation de la table\n"); table_int = calloc (NB_INT, sizeof (int)); fprintf (stdout, "On déborde vers le haut\n"); for (i = 0; i <= NB_INT; i ++) table_int [i] = 1; fprintf (stdout, "Libération de la table\n"); free (table_int); fprintf (stdout, "Allocation de la table\n"); table_int = calloc (NB_INT, sizeof (int)); fprintf (stdout, "On déborde vers le bas\n"); i = NB_INT; while (i >= 0) table_int [--i] = 1; fprintf (stdout, "Libération de la table\n"); free (table_int); fprintf (stdout, "Allocation de la table\n"); table_int = calloc (NB_INT, sizeof (int)); fprintf (stdout, "Ecriture normale\n"); for (i = 0; i < NB_INT; i ++) table_int [i] = 0; fprintf (stdout, "Libération de la table\n"); free (table_int); fprintf (stdout, "Et re-libération de la table !\n"); free (table_int); return (0); }
/* * INVOCATION * * $0 INPUT-FILENAME OUTPUT-FILENAME * * The input file must be in sg0 format; the output file is in sg1 format. */ int main(int argc, char **argv) { #ifndef NDEBUG if (mcheck(NULL)) exit(1); #endif if (argc != 3) { fprintf(stderr, "*** Invalid number of arguments\n"); exit(1); } const char *filename_in= argv[1]; const char *filename_out= argv[2]; struct sgraph0_reader_a r; if (0 > sgraph0_open_read_a(filename_in, &r, COLS_ALL)) { exit(1); } if (0 > sgraph0_advise_a(&r, MADV_SEQUENTIAL)) { perror(filename_in); goto error_close; } struct graph_a g; graph_read_sgraph0_a(&g, &r); sgraph0_close_a(&r); graph_sort_a(&g); if (0 > sgraph1_write_a(&g, filename_out)) { exit(1); } exit(0); error_close: sgraph0_close_a(&r); exit(1); }
int main(int argc, char **argv) { #ifdef MLR_USE_MCHECK if (mcheck(NULL) != 0) { printf("Could not set up mcheck\n"); exit(1); } printf("Set up mcheck\n"); #endif // MLR_USE_MCHECK char *result = run_all_tests(); printf("\n"); if (result != 0) { printf("Not all unit tests passed\n"); } else { printf("TEST_LREC: ALL UNIT TESTS PASSED\n"); } printf("Tests passed: %d of %d\n", tests_run - tests_failed, tests_run); printf("Assertions passed: %d of %d\n", assertions_run - assertions_failed, assertions_run); return result != 0; }
static void turn_on_mcheck (void) { mcheck (NULL); }
/** * Test program looping and reading LLDP/CDP packets and exercising most of the packet * send/receive mechanism and a good bit of nanoprobe and CMA basic infrastructure. * * It plays both sides of the game - the CMA and the nanoprobe. * * It leaves most of the work of starting up the nanoprobe code to nano_start_full() */ int main(int argc, char **argv) { const guint8 loopback[] = CONST_IPV6_LOOPBACK; //const guint8 mcastaddrstring[] = CONST_ASSIM_DEFAULT_V4_MCAST; //NetAddr* mcastaddr; const guint8 otheradstring[] = {127,0,0,1}; const guint8 otheradstring2[] = {10,10,10,4}; const guint8 anyadstring[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; guint16 testport = TESTPORT; SignFrame* signature = signframe_glib_new(G_CHECKSUM_SHA256, 0); Listener* otherlistener; ConfigContext* config = configcontext_new(0); PacketDecoder* decoder = nano_packet_decoder(); AuthListener* listentonanoprobes; ReliableUDP* rtransport; #if 0 # ifdef HAVE_MCHECK_PEDANTIC g_assert(mcheck_pedantic(NULL) == 0); # else # ifdef HAVE_MCHECK g_assert(mcheck(NULL) == 0); # endif # endif #endif g_setenv("G_MESSAGES_DEBUG", "all", TRUE); #if 0 proj_class_incr_debug(NULL); proj_class_incr_debug(NULL); proj_class_incr_debug(NULL); proj_class_incr_debug(NULL); #endif g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR); if (argc > 1) { maxpkts = atol(argv[1]); g_debug("Max packet count is "FMT_64BIT"d", maxpkts); } if (netio_is_dual_ipv4v6_stack()) { g_message("Our OS supports dual ipv4/v6 sockets. Hurray!"); }else{ g_warning("Our OS DOES NOT support dual ipv4/v6 sockets - this may not work!!"); } config->setframe(config, CONFIGNAME_OUTSIG, &signature->baseclass); // Create a network transport object for normal UDP packets rtransport = reliableudp_new(0, config, decoder, 0); rtransport->_protocol->window_size = 8; nettransport = &(rtransport->baseclass.baseclass); g_return_val_if_fail(NULL != nettransport, 2); // Set up the parameters the 'CMA' is going to send to our 'nanoprobe' // in response to their request for configuration data. nanoconfig = configcontext_new(0); nanoconfig->setint(nanoconfig, CONFIGNAME_INTERVAL, 1); nanoconfig->setint(nanoconfig, CONFIGNAME_TIMEOUT, 3); nanoconfig->setint(nanoconfig, CONFIGNAME_CMAPORT, testport); // Construct the NetAddr we'll talk to (i.e., ourselves) and listen from destaddr = netaddr_ipv6_new(loopback, testport); g_return_val_if_fail(NULL != destaddr, 3); config->setaddr(config, CONFIGNAME_CMAINIT, destaddr); nanoconfig->setaddr(nanoconfig, CONFIGNAME_CMAADDR, destaddr); nanoconfig->setaddr(nanoconfig, CONFIGNAME_CMAFAIL, destaddr); nanoconfig->setaddr(nanoconfig, CONFIGNAME_CMADISCOVER, destaddr); // Construct another couple of NetAddrs to talk to and listen from // for good measure... otheraddr = netaddr_ipv4_new(otheradstring, testport); g_return_val_if_fail(NULL != otheraddr, 4); otheraddr2 = netaddr_ipv4_new(otheradstring2, testport); g_return_val_if_fail(NULL != otheraddr2, 4); // Construct another NetAddr to bind to (anything) anyaddr = netaddr_ipv6_new(anyadstring, testport); g_return_val_if_fail(NULL != destaddr, 5); // Bind to ANY address (as noted above) g_return_val_if_fail(nettransport->bindaddr(nettransport, anyaddr, FALSE),16); //g_return_val_if_fail(nettransport->bindaddr(nettransport, destaddr),16); g_message("NOT Joining multicast address."); #if 0 // We can't do this because of encryption and we will likely screw up // others on our network even if that weren't a problem... mcastaddr = netaddr_ipv4_new(mcastaddrstring, testport); g_return_val_if_fail(nettransport->mcastjoin(nettransport, mcastaddr, NULL), 17); UNREF(mcastaddr); g_message("multicast join succeeded."); #endif // Connect up our network transport into the g_main_loop paradigm // so we get dispatched when packets arrive netpkt = netgsource_new(nettransport, NULL, G_PRIORITY_HIGH, FALSE, NULL, 0, NULL); // Set up so that we can observe all unclaimed packets otherlistener = listener_new(config, 0); otherlistener->got_frameset = gotnetpkt; netpkt->addListener(netpkt, 0, otherlistener); otherlistener->associate(otherlistener,netpkt); // Unref the "other" listener - we hold other references to it UNREF(otherlistener); // Pretend to be the CMA... // Listen for packets from our nanoprobes - scattered throughout space... listentonanoprobes = authlistener_new(0, cmalist, config, TRUE, NULL); listentonanoprobes->baseclass.associate(&listentonanoprobes->baseclass, netpkt); nano_start_full("netconfig", 900, netpkt, config, test_cma_authentication); g_timeout_add_seconds(1, timeout_agent, NULL); mainloop = g_main_loop_new(g_main_context_default(), TRUE); /******************************************************************** * Start up the main loop - run our test program... * (the one pretending to be both the nanoprobe and the CMA) ********************************************************************/ g_main_loop_run(mainloop); /******************************************************************** * We exited the main loop. Shut things down. ********************************************************************/ nano_shutdown(TRUE); // Tell it to shutdown and print stats g_message("Count of 'other' pkts received:\t%d", wirepktcount); UNREF(nettransport); // Main loop is over - shut everything down, free everything... g_main_loop_unref(mainloop); mainloop=NULL; // Unlink misc dispatcher - this should NOT be necessary... netpkt->addListener(netpkt, 0, NULL); // Dissociate packet actions from the packet source. listentonanoprobes->baseclass.dissociate(&listentonanoprobes->baseclass); // Unref the AuthListener object UNREF2(listentonanoprobes); g_source_destroy(&netpkt->baseclass); g_source_unref(&netpkt->baseclass); //g_main_context_unref(g_main_context_default()); // Free signature frame UNREF2(signature); // Free misc addresses UNREF(destaddr); UNREF(otheraddr); UNREF(otheraddr2); UNREF(anyaddr); // Free config object UNREF(config); UNREF(nanoconfig); // At this point - nothing should show up - we should have freed everything if (proj_class_live_object_count() > 0) { g_warning("Too many objects (%d) alive at end of test.", proj_class_live_object_count()); proj_class_dump_live_objects(); ++errcount; }else{ g_message("No objects left alive. Awesome!"); } proj_class_finalize_sys(); // Shut down object system to make valgrind happy :-D return(errcount <= 127 ? errcount : 127); }
void SweepGenblock::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int stateA, int stateB) { if (dmrginp.outputlevel() > 0) mcheck("at the start of block and decimate"); p1out << "\t\t\t Performing Blocking"<<endl; dmrginp.guessgenT -> start(); // figure out if we are going forward or backwards bool forward = (system.get_sites() [0] == 0); SpinBlock systemDot; int systemDotStart, systemDotEnd; int systemDotSize = sweepParams.get_sys_add() - 1; if (forward) { systemDotStart = dmrginp.spinAdapted() ? *system.get_sites().rbegin () + 1 : (*system.get_sites().rbegin ())/2 + 1 ; systemDotEnd = systemDotStart + systemDotSize; } else { systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ; systemDotEnd = systemDotStart - systemDotSize; } vector<int> spindotsites(2); spindotsites[0] = systemDotStart; spindotsites[1] = systemDotEnd; dmrginp.sysdotmake->start(); systemDot = SpinBlock(systemDotStart, systemDotEnd, system.get_integralIndex(), stateA==stateB); dmrginp.sysdotmake->stop(); const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size(); dmrginp.guessgenT -> stop(); dmrginp.datatransfer -> start(); system.addAdditionalCompOps(); dmrginp.datatransfer -> stop(); dmrginp.initnewsystem->start(); InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, stateA, stateB, sweepParams.get_sys_add(), dmrginp.direct(), system.get_integralIndex(), DISTRIBUTED_STORAGE, dot_with_sys, true); dmrginp.initnewsystem->stop(); pout << "\t\t\t System Block"<<newSystem; newSystem.printOperatorSummary(); std::vector<Matrix> leftrotateMatrix, rightrotateMatrix; LoadRotationMatrix (newSystem.get_sites(), leftrotateMatrix, stateA); LoadRotationMatrix (newSystem.get_sites(), rightrotateMatrix, stateB); #ifndef SERIAL mpi::communicator world; broadcast(world, leftrotateMatrix, 0); broadcast(world, rightrotateMatrix, 0); #endif p1out <<"\t\t\t Performing Renormalization "<<endl<<endl; dmrginp.operrotT->start(); if (stateB == stateA) newSystem.transform_operators(leftrotateMatrix); else newSystem.transform_operators(leftrotateMatrix, rightrotateMatrix); dmrginp.operrotT->stop(); if (dmrginp.outputlevel() > 0) //mcheck("after rotation and transformation of block"); p2out <<newSystem<<endl; newSystem.printOperatorSummary(); //mcheck("After renorm transform"); p2out << *dmrginp.guessgenT<<" "<<*dmrginp.multiplierT<<" "<<*dmrginp.operrotT<< " "<<globaltimer.totalwalltime()<<" timer "<<endl; p2out << *dmrginp.makeopsT<<" "<<*dmrginp.initnewsystem<<" "<<*dmrginp.sysdotmake<<" "<<*dmrginp.buildcsfops<<" makeops "<<endl; p2out << *dmrginp.datatransfer<<" datatransfer "<<endl; p2out <<"oneindexopmult twoindexopmult Hc couplingcoeff"<<endl; p2out << *dmrginp.oneelecT<<" "<<*dmrginp.twoelecT<<" "<<*dmrginp.hmultiply<<" "<<*dmrginp.couplingcoeff<<" hmult"<<endl; p2out << *dmrginp.buildsumblock<<" "<<*dmrginp.buildblockops<<" build block"<<endl; p2out << *dmrginp.blockintegrals<<" "<<*dmrginp.blocksites<<" "<<*dmrginp.statetensorproduct<<" "<<*dmrginp.statecollectquanta<<" "<<*dmrginp.buildsumblock<<" "<<*dmrginp.builditeratorsT<<" "<<*dmrginp.diskio<<" build sum block"<<endl; p2out << "addnoise S_0_opxop S_1_opxop S_2_opxop"<<endl; p3out << *dmrginp.addnoise<<" "<<*dmrginp.s0time<<" "<<*dmrginp.s1time<<" "<<*dmrginp.s2time<<endl; }
int main (int argc, char *argv[]) { errcode_t retval = 0; int exit_value = FSCK_OK; ext2_filsys fs = 0; io_manager io_ptr; struct ext2_super_block *sb; const char *lib_ver_date; int my_ver, lib_ver; e2fsck_t ctx; struct problem_context pctx; int flags, run_result; clear_problem_context(&pctx); #ifdef MTRACE mtrace(); #endif #ifdef MCHECK mcheck(0); #endif #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); setlocale(LC_CTYPE, ""); bindtextdomain(NLS_CAT_NAME, LOCALEDIR); textdomain(NLS_CAT_NAME); #endif my_ver = ext2fs_parse_version_string(my_ver_string); lib_ver = ext2fs_get_library_version(0, &lib_ver_date); if (my_ver > lib_ver) { fprintf( stderr, _("Error: ext2fs library version " "out of date!\n")); show_version_only++; } retval = PRS(argc, argv, &ctx); if (retval) { com_err("e2fsck", retval, _("while trying to initialize program")); exit(FSCK_ERROR); } reserve_stdio_fds(); #ifdef RESOURCE_TRACK init_resource_track(&ctx->global_rtrack); #endif if (!(ctx->options & E2F_OPT_PREEN) || show_version_only) fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string, my_ver_date); if (show_version_only) { fprintf(stderr, _("\tUsing %s, %s\n"), error_message(EXT2_ET_BASE), lib_ver_date); exit(FSCK_OK); } check_mount(ctx); if (!(ctx->options & E2F_OPT_PREEN) && !(ctx->options & E2F_OPT_NO) && !(ctx->options & E2F_OPT_YES)) { if (!ctx->interactive) fatal_error(ctx, _("need terminal for interactive repairs")); } ctx->superblock = ctx->use_superblock; restart: #ifdef CONFIG_TESTIO_DEBUG io_ptr = test_io_manager; test_io_backing_manager = unix_io_manager; #else io_ptr = unix_io_manager; #endif flags = 0; if ((ctx->options & E2F_OPT_READONLY) == 0) flags |= EXT2_FLAG_RW; if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0) flags |= EXT2_FLAG_EXCLUSIVE; if (ctx->superblock && ctx->blocksize) { retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, flags, ctx->superblock, ctx->blocksize, io_ptr, &fs); } else if (ctx->superblock) { int blocksize; for (blocksize = EXT2_MIN_BLOCK_SIZE; blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, flags, ctx->superblock, blocksize, io_ptr, &fs); if (!retval) break; } } else retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, flags, 0, 0, io_ptr, &fs); if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && !(ctx->flags & E2F_FLAG_SB_SPECIFIED) && ((retval == EXT2_ET_BAD_MAGIC) || ((retval == 0) && ext2fs_check_desc(fs)))) { if (!fs || (fs->group_desc_count > 1)) { printf(_("%s trying backup blocks...\n"), retval ? _("Couldn't find ext2 superblock,") : _("Group descriptors look bad...")); get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr); if (fs) ext2fs_close(fs); goto restart; } } if (retval) { com_err(ctx->program_name, retval, _("while trying to open %s"), ctx->filesystem_name); if (retval == EXT2_ET_REV_TOO_HIGH) { printf(_("The filesystem revision is apparently " "too high for this version of e2fsck.\n" "(Or the filesystem superblock " "is corrupt)\n\n")); fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); } else if (retval == EXT2_ET_SHORT_READ) printf(_("Could this be a zero-length partition?\n")); else if ((retval == EPERM) || (retval == EACCES)) printf(_("You must have %s access to the " "filesystem or be root\n"), (ctx->options & E2F_OPT_READONLY) ? "r/o" : "r/w"); else if (retval == ENXIO) printf(_("Possibly non-existent or swap device?\n")); else if (retval == EBUSY) printf(_("Filesystem mounted or opened exclusively " "by another program?\n")); #ifdef EROFS else if (retval == EROFS) printf(_("Disk write-protected; use the -n option " "to do a read-only\n" "check of the device.\n")); #endif else fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); fatal_error(ctx, 0); } ctx->fs = fs; fs->priv_data = ctx; fs->now = ctx->now; sb = fs->super; if (sb->s_rev_level > E2FSCK_CURRENT_REV) { com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH, _("while trying to open %s"), ctx->filesystem_name); get_newer: fatal_error(ctx, _("Get a newer version of e2fsck!")); } /* * Set the device name, which is used whenever we print error * or informational messages to the user. */ if (ctx->device_name == 0 && (sb->s_volume_name[0] != 0)) { ctx->device_name = string_copy(ctx, sb->s_volume_name, sizeof(sb->s_volume_name)); } if (ctx->device_name == 0) ctx->device_name = ctx->filesystem_name; /* * Make sure the ext3 superblock fields are consistent. */ retval = e2fsck_check_ext3_journal(ctx); if (retval) { com_err(ctx->program_name, retval, _("while checking ext3 journal for %s"), ctx->device_name); fatal_error(ctx, 0); } /* * Check to see if we need to do ext3-style recovery. If so, * do it, and then restart the fsck. */ if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) { if (ctx->options & E2F_OPT_READONLY) { printf(_("Warning: skipping journal recovery " "because doing a read-only filesystem " "check.\n")); io_channel_flush(ctx->fs->io); } else { if (ctx->flags & E2F_FLAG_RESTARTED) { /* * Whoops, we attempted to run the * journal twice. This should never * happen, unless the hardware or * device driver is being bogus. */ com_err(ctx->program_name, 0, _("unable to set superblock flags on %s\n"), ctx->device_name); fatal_error(ctx, 0); } retval = e2fsck_run_ext3_journal(ctx); if (retval) { com_err(ctx->program_name, retval, _("while recovering ext3 journal of %s"), ctx->device_name); fatal_error(ctx, 0); } ext2fs_close(ctx->fs); ctx->fs = 0; ctx->flags |= E2F_FLAG_RESTARTED; goto restart; } } /* * Check for compatibility with the feature sets. We need to * be more stringent than ext2fs_open(). */ if ((sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) || (sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) { com_err(ctx->program_name, EXT2_ET_UNSUPP_FEATURE, "(%s)", ctx->device_name); goto get_newer; } if (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) { com_err(ctx->program_name, EXT2_ET_RO_UNSUPP_FEATURE, "(%s)", ctx->device_name); goto get_newer; } #ifdef ENABLE_COMPRESSION if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION) com_err(ctx->program_name, 0, _("Warning: compression support is experimental.\n")); #endif #ifndef ENABLE_HTREE if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) { com_err(ctx->program_name, 0, _("E2fsck not compiled with HTREE support,\n\t" "but filesystem %s has HTREE directories.\n"), ctx->device_name); goto get_newer; } #endif /* * If the user specified a specific superblock, presumably the * master superblock has been trashed. So we mark the * superblock as dirty, so it can be written out. */ if (ctx->superblock && !(ctx->options & E2F_OPT_READONLY)) ext2fs_mark_super_dirty(fs); /* * We only update the master superblock because (a) paranoia; * we don't want to corrupt the backup superblocks, and (b) we * don't need to update the mount count and last checked * fields in the backup superblock (the kernel doesn't * update the backup superblocks anyway). */ fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; ehandler_init(fs->io); if (ctx->superblock) set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); ext2fs_mark_valid(fs); check_super_block(ctx); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); check_if_skip(ctx); if (bad_blocks_file) read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks); else if (cflag) read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */ if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); #ifdef ENABLE_SWAPFS if (normalize_swapfs) { if ((fs->flags & EXT2_FLAG_SWAP_BYTES) == ext2fs_native_flag()) { fprintf(stderr, _("%s: Filesystem byte order " "already normalized.\n"), ctx->device_name); fatal_error(ctx, 0); } } if (swapfs) { swap_filesys(ctx); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); } #endif /* * Mark the system as valid, 'til proven otherwise */ ext2fs_mark_valid(fs); retval = ext2fs_read_bb_inode(fs, &fs->badblocks); if (retval) { com_err(ctx->program_name, retval, _("while reading bad blocks inode")); preenhalt(ctx); printf(_("This doesn't bode well," " but we'll try to go on...\n")); } run_result = e2fsck_run(ctx); e2fsck_clear_progbar(ctx); if (run_result == E2F_FLAG_RESTART) { printf(_("Restarting e2fsck from the beginning...\n")); retval = e2fsck_reset_context(ctx); if (retval) { com_err(ctx->program_name, retval, _("while resetting context")); fatal_error(ctx, 0); } ext2fs_close(fs); goto restart; } if (run_result & E2F_FLAG_CANCEL) { printf(_("%s: e2fsck canceled.\n"), ctx->device_name ? ctx->device_name : ctx->filesystem_name); exit_value |= FSCK_CANCELED; } if (run_result & E2F_FLAG_ABORT) fatal_error(ctx, _("aborted")); #ifdef MTRACE mtrace_print("Cleanup"); #endif if (ext2fs_test_changed(fs)) { exit_value |= FSCK_NONDESTRUCT; if (!(ctx->options & E2F_OPT_PREEN)) printf(_("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"), ctx->device_name); if (ctx->mount_flags & EXT2_MF_ISROOT) { printf(_("%s: ***** REBOOT LINUX *****\n"), ctx->device_name); exit_value |= FSCK_REBOOT; } } if (!ext2fs_test_valid(fs) || ((exit_value & FSCK_CANCELED) && (sb->s_state & EXT2_ERROR_FS))) { printf(_("\n%s: ********** WARNING: Filesystem still has " "errors **********\n\n"), ctx->device_name); exit_value |= FSCK_UNCORRECTED; exit_value &= ~FSCK_NONDESTRUCT; } if (exit_value & FSCK_CANCELED) { int allow_cancellation; profile_get_boolean(ctx->profile, "options", "allow_cancellation", 0, 0, &allow_cancellation); exit_value &= ~FSCK_NONDESTRUCT; if (allow_cancellation && ext2fs_test_valid(fs) && (sb->s_state & EXT2_VALID_FS) && !(sb->s_state & EXT2_ERROR_FS)) exit_value = 0; } else { show_stats(ctx); if (!(ctx->options & E2F_OPT_READONLY)) { if (ext2fs_test_valid(fs)) { if (!(sb->s_state & EXT2_VALID_FS)) exit_value |= FSCK_NONDESTRUCT; sb->s_state = EXT2_VALID_FS; } else sb->s_state &= ~EXT2_VALID_FS; sb->s_mnt_count = 0; sb->s_lastcheck = ctx->now; ext2fs_mark_super_dirty(fs); } } e2fsck_write_bitmaps(ctx); ext2fs_close(fs); ctx->fs = NULL; free(ctx->filesystem_name); free(ctx->journal_name); #ifdef RESOURCE_TRACK if (ctx->options & E2F_OPT_TIME) print_resource_track(NULL, &ctx->global_rtrack); #endif e2fsck_free_context(ctx); return exit_value; }
/* * Go through the whole list, stopping if you find a match. Process all * the continuations of that match before returning. * * We support multi-level continuations: * * At any time when processing a successful top-level match, there is a * current continuation level; it represents the level of the last * successfully matched continuation. * * Continuations above that level are skipped as, if we see one, it * means that the continuation that controls them - i.e, the * lower-level continuation preceding them - failed to match. * * Continuations below that level are processed as, if we see one, * it means we've finished processing or skipping higher-level * continuations under the control of a successful or unsuccessful * lower-level continuation, and are now seeing the next lower-level * continuation and should process it. The current continuation * level reverts to the level of the one we're seeing. * * Continuations at the current level are processed as, if we see * one, there's no lower-level continuation that may have failed. * * If a continuation matches, we bump the current continuation level * so that higher-level continuations are processed. */ char * magic_match(u_char *s, int len) { int i, cont_level = 0; union VALUETYPE p; static int32_t *tmpoff = NULL; static size_t tmplen = 0; int32_t oldoff = 0; Match[0] = '\0'; if (tmpoff == NULL) if ((tmpoff = (int32_t *) malloc(tmplen = 20)) == NULL) err(1, "malloc"); for (i = 0; i < Magiccnt; i++) { /* if main entry matches, print it... */ if (!mget(&p, s, &Magic[i], len) || !mcheck(&p, &Magic[i])) { /* * main entry didn't match, * flush its continuations */ while (i < Magiccnt && Magic[i + 1].cont_level != 0) i++; continue; } tmpoff[cont_level] = mprint(&p, &Magic[i]); /* and any continuations that match */ if (++cont_level >= tmplen) { tmplen += 20; if (!(tmpoff = (int32_t *) realloc(tmpoff, tmplen))) err(1, "magic_match: malloc"); } while (Magic[i + 1].cont_level != 0 && ++i < Magiccnt) { if (cont_level >= Magic[i].cont_level) { if (cont_level > Magic[i].cont_level) { /* * We're at the end of the level * "cont_level" continuations. */ cont_level = Magic[i].cont_level; } if (Magic[i].flag & ADD) { oldoff = Magic[i].offset; Magic[i].offset += tmpoff[cont_level - 1]; } if (mget(&p, s, &Magic[i], len) && mcheck(&p, &Magic[i])) { /* This continuation matched. */ tmpoff[cont_level] = mprint(&p, &Magic[i]); /* * If we see any continuations * at a higher level, process them. */ if (++cont_level >= tmplen) { tmplen += 20; if (!(tmpoff = (int32_t *) realloc(tmpoff, tmplen))) err(1, "magic_check: " "malloc"); } } if (Magic[i].flag & ADD) { Magic[i].offset = oldoff; } } } return (strlen(Match) ? Match : NULL); /* all through */ } return (NULL); /* no match at all */ }
void SpinAdapted::InitBlocks::InitNewEnvironmentBlock(SpinBlock &environment, SpinBlock& environmentDot, SpinBlock &newEnvironment, const SpinBlock &system, SpinBlock &systemDot, int leftState, int rightState, const int &sys_add, const int &env_add, const bool &forward, const bool &direct, const bool &onedot, const bool &nexact, const bool &useSlater, int integralIndex, bool haveNormops, bool haveCompops, const bool& dot_with_sys, int constraint, const std::vector<SpinQuantum>& braquanta, const std::vector<SpinQuantum>& ketquanta) { // now initialise environment Dot int systemDotStart, systemDotEnd, environmentDotStart, environmentDotEnd, environmentStart, environmentEnd; int systemDotSize = sys_add - 1; int environmentDotSize = env_add - 1; if (forward) { systemDotStart = dmrginp.spinAdapted() ? *system.get_sites().rbegin () + 1 : (*system.get_sites().rbegin ())/2 + 1 ; systemDotEnd = systemDotStart + systemDotSize; environmentDotStart = systemDotEnd + 1; environmentDotEnd = environmentDotStart + environmentDotSize; environmentStart = environmentDotEnd + 1; environmentEnd = dmrginp.spinAdapted() ? dmrginp.last_site() - 1 : dmrginp.last_site()/2 - 1; } else { systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ; systemDotEnd = systemDotStart - systemDotSize; environmentDotStart = systemDotEnd - 1; environmentDotEnd = environmentDotStart - environmentDotSize; environmentStart = environmentDotEnd - 1; environmentEnd = 0; } std::vector<int> environmentSites; environmentSites.resize(abs(environmentEnd - environmentStart) + 1); for (int i = 0; i < abs(environmentEnd - environmentStart) + 1; ++i) *(environmentSites.begin () + i) = min(environmentStart,environmentEnd) + i; // now initialise environment if (useSlater) { // for FCI StateInfo system_stateinfo = system.get_stateInfo(); StateInfo sysdot_stateinfo = systemDot.get_stateInfo(); StateInfo tmp; TensorProduct (system_stateinfo, sysdot_stateinfo, tmp, NO_PARTICLE_SPIN_NUMBER_CONSTRAINT); // tmp has the system+dot quantum numbers tmp.CollectQuanta (); // exact environment if (dmrginp.do_fci() || environmentSites.size() == nexact) { if ((!dot_with_sys && onedot) || !onedot) { // environment has dot environment.set_integralIndex() = integralIndex; environment.default_op_components(!forward, leftState==rightState); environment.setstoragetype(DISTRIBUTED_STORAGE); environment.BuildTensorProductBlock(environmentSites); // exact block SpinBlock::store (true, environmentSites, environment, leftState, rightState); } else { // environment has no dot, so newEnv = Env newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(!forward, leftState==rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildTensorProductBlock(environmentSites); SpinBlock::store (true, environmentSites, newEnvironment, leftState, rightState); } } else if (dmrginp.warmup() == LOCAL2 || dmrginp.warmup() == LOCAL3 || dmrginp.warmup() == LOCAL4) { int nactiveSites, ncoreSites; if (dmrginp.warmup() == LOCAL2) { nactiveSites = 1; } else if (dmrginp.warmup() == LOCAL3) { nactiveSites = 2; } else if (dmrginp.warmup() == LOCAL4) { nactiveSites = 3; } if (dot_with_sys && onedot) { nactiveSites += 1; } if (nactiveSites > environmentSites.size()) { nactiveSites = environmentSites.size(); } ncoreSites = environmentSites.size() - nactiveSites; // figure out what sites are in the active and core sites int environmentActiveEnd = forward ? environmentStart + nactiveSites - 1 : environmentStart - nactiveSites + 1; int environmentCoreStart = forward ? environmentActiveEnd + 1 : environmentActiveEnd - 1; std::vector<int> activeSites(nactiveSites), coreSites(ncoreSites); for (int i = 0; i < nactiveSites; ++i) { activeSites[i] = min(environmentStart,environmentActiveEnd) + i; } for (int i = 0; i < ncoreSites; ++i) { coreSites[i] = min(environmentCoreStart,environmentEnd) + i; } SpinBlock environmentActive, environmentCore; environmentActive.nonactive_orb() = system.nonactive_orb(); environmentCore.nonactive_orb() = system.nonactive_orb(); if (coreSites.size() > 0) { environmentActive.set_integralIndex() = integralIndex; environmentCore.set_integralIndex() = integralIndex; environmentActive.default_op_components(!forward, leftState==rightState); environmentActive.setstoragetype(DISTRIBUTED_STORAGE); environmentCore.default_op_components(!forward, leftState==rightState); environmentCore.setstoragetype(DISTRIBUTED_STORAGE); environmentActive.BuildTensorProductBlock(activeSites); environmentCore.BuildSingleSlaterBlock(coreSites); dmrginp.datatransfer -> start(); environmentCore.addAdditionalCompOps(); environmentActive.addAdditionalCompOps(); dmrginp.datatransfer -> stop(); if ((!dot_with_sys && onedot) || !onedot) { environment.set_integralIndex() = integralIndex; environment.default_op_components(!forward, leftState == rightState); environment.setstoragetype(DISTRIBUTED_STORAGE); environment.BuildSumBlock(constraint, environmentCore, environmentActive,braquanta,ketquanta); } else { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(direct, environmentCore, environmentActive, haveNormops, haveCompops, leftState == rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildSumBlock(constraint, environmentCore, environmentActive,braquanta,ketquanta); if (dmrginp.outputlevel() > 0) { pout << "\t\t\t NewEnvironment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } } } else { // no core if ((!dot_with_sys && onedot) || !onedot) { environment.set_integralIndex() = integralIndex; environment.default_op_components(!forward, leftState==rightState); environment.setstoragetype(DISTRIBUTED_STORAGE); environment.BuildTensorProductBlock(environmentSites); // exact block } else { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(!forward, leftState==rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildTensorProductBlock(environmentSites); } } } else { //used for warmup guess environemnt std::vector<SpinQuantum> quantumNumbers; std::vector<int> distribution; std::map<SpinQuantum, int> quantaDist; std::map<SpinQuantum, int>::iterator quantaIterator; bool environmentComplementary = !forward; StateInfo tmp2; // tmp is the quantum numbers of newSystem (sys + sysdot) if (onedot) tmp.quanta_distribution (quantumNumbers, distribution, true); else { StateInfo environmentdot_stateinfo = environmentDot.get_stateInfo(); TensorProduct (tmp, environmentdot_stateinfo, tmp2, constraint); tmp2.CollectQuanta (); tmp2.quanta_distribution (quantumNumbers, distribution, true); } for (int i = 0; i < distribution.size (); ++i) { quantaIterator = quantaDist.find(quantumNumbers[i]); if (quantaIterator != quantaDist.end()) distribution[i] += quantaIterator->second; distribution [i] /= 4; distribution [i] += 1; if (distribution [i] > dmrginp.nquanta()) distribution [i] = dmrginp.nquanta(); if(quantaIterator != quantaDist.end()) { quantaIterator->second = distribution[i]; } else { quantaDist[quantumNumbers[i]] = distribution[i]; } } if (dmrginp.outputlevel() > 0) pout << "\t\t\t Quantum numbers and states used for warm up :: " << endl << "\t\t\t "; quantumNumbers.clear(); quantumNumbers.reserve(distribution.size()); distribution.clear();distribution.reserve(quantumNumbers.size()); std::map<SpinQuantum, int>::iterator qit = quantaDist.begin(); for (; qit != quantaDist.end(); qit++) { quantumNumbers.push_back( qit->first); distribution.push_back(qit->second); if (dmrginp.outputlevel() > 0) { pout << quantumNumbers.back() << " = " << distribution.back() << ", "; if (! (quantumNumbers.size() - 6) % 6) pout << endl << "\t\t\t "; } } pout << endl; if(dot_with_sys && onedot) { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.BuildSlaterBlock (environmentSites, quantumNumbers, distribution, false, false); } else { environment.set_integralIndex() = integralIndex; environment.BuildSlaterBlock (environmentSites, quantumNumbers, distribution, false, haveNormops); } } } else { if (dmrginp.outputlevel() > 0) pout << "\t\t\t Restoring block of size " << environmentSites.size () << " from previous iteration" << endl; if(dot_with_sys && onedot) { newEnvironment.set_integralIndex() = integralIndex; SpinBlock::restore (!forward, environmentSites, newEnvironment, leftState, rightState); } else { environment.set_integralIndex() = integralIndex; SpinBlock::restore (!forward, environmentSites, environment, leftState, rightState); } if (dmrginp.outputlevel() > 0) mcheck(""); } // now initialise newEnvironment if (!dot_with_sys || !onedot) { dmrginp.datatransfer -> start(); environment.addAdditionalCompOps(); dmrginp.datatransfer -> stop(); newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(direct, environment, environmentDot, haveNormops, haveCompops, leftState==rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildSumBlock (constraint, environment, environmentDot,braquanta,ketquanta); if (dmrginp.outputlevel() > -1) { pout << "\t\t\t Environment block " << endl << environment << endl; environment.printOperatorSummary(); pout << "\t\t\t NewEnvironment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } } else if (dmrginp.outputlevel() > 0) { pout << "\t\t\t Environment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } }
int main(int argc, char *argv[]) { int count; seq_t seq1, seq2; hash_env_t he; collec_t res, rev_res; #if defined(DEBUG) && (DEBUG > 1) mcheck(NULL); mtrace(); #endif argv0 = argv[0]; if (setlocale(LC_ALL, "POSIX") == NULL) fprintf(stderr, "%s: Warning: could not set locale to POSIX\n", argv[0]); signal(SIGSEGV, bug_handler); #ifndef __MINGW32__ signal(SIGBUS, bug_handler); #endif /* Default options. */ options.C = DEFAULT_C; options.cutoff = DIST_CUTOFF; options.gapPct = DEFAULT_GAPPCT; options.intron_window = 6; options.K = DEFAULT_K; options.splice_type_list = "GTAG,GCAG,GTAC,ATAC"; options.nbSplice = 4; options.scoreSplice_window = 10; options.mismatchScore = MISMATCH; options.reverse = 2; options.matchScore = MATCH; options.W = DEFAULT_W; options.X = DEFAULT_X; options.filterPct = DEFAULT_FILTER; options.minScore_cutoff = MATCH_CUTOFF; while (1) { int c = getopt(argc, argv, "A:C:c:E:f:g:I:K:L:M:o:q:R:r:W:X:"); if (c == -1) break; switch (c) { case 'A': options.ali_flag = atoi(optarg); if (options.ali_flag < 0 || options.ali_flag > 4) fatal("A must be one of 0, 1, 2, 3, or 4.\n"); break; case 'C': { int val = atoi(optarg); if (val < 0) fatal("Value for option C must be non-negative.\n"); options.C = val; break; } case 'c': { int val = atoi(optarg); if (val < 0) fatal("Value for option c must be non-negative.\n"); options.minScore_cutoff = val; break; } case 'E': options.cutoff = atoi(optarg); if (options.cutoff < 3 || options.cutoff > 10) fatal("Cutoff (E) must be within [3,10].\n"); break; case 'f': options.filterPct = atoi(optarg); if (options.filterPct > 100) fatal("Filter in percent (f) must be within [0,100].\n"); break; case 'g': options.gapPct = atoi(optarg); break; case 'I': options.intron_window = atoi(optarg); break; case 'K': { int val = atoi(optarg); if (val < 0) fatal("Value for option K must be non-negative.\n"); options.K = val; break; } case 'L': { size_t i; size_t len = strlen(optarg); options.splice_type_list = optarg; options.nbSplice = 1; if (len % 5 != 4) fatal("Splice types list has illegal length (%zu)\n", len); for (i = 0; i < len; i++) if (i % 5 == 4) { if (options.splice_type_list[i] != ',') fatal("Comma expected instead of %c at position %zu" "in splice types list.\n", options.splice_type_list[i], i); options.nbSplice += 1; } else { if (options.splice_type_list[i] != 'A' && options.splice_type_list[i] != 'C' && options.splice_type_list[i] != 'G' && options.splice_type_list[i] != 'T') fatal("Expected 'A', 'C', 'G' or 'T' instead of '%c' at" "position %zu in splice types list.\n", options.splice_type_list[i], i); } break; } case 'M': { int val = atoi(optarg); if (val < 0) fatal("Value for option M must be non-negative.\n"); options.scoreSplice_window = val; break; } case 'o': options.dnaOffset = atoi(optarg); break; case 'q': options.mismatchScore = atoi(optarg); break; case 'R': options.reverse = atoi(optarg); if (options.reverse < 0 || options.reverse > 2) fatal("R must be one of 0, 1, or 2.\n"); break; case 'r': options.matchScore = atoi(optarg); break; case 'W': options.W = atoi(optarg); if (options.W < 1 || options.W > 15) fatal("W must be within [1,15].\n"); break; case 'X': options.X = atoi(optarg); if (options.X < 1) fatal("X must be positive.\n"); break; case '?': break; default: fprintf(stderr, "?? getopt returned character code 0%o ??\n", c); } } if (optind + 2 != argc) { fprintf(stderr, Usage, argv[0], options.ali_flag, options.C, options.minScore_cutoff, options.cutoff, options.filterPct, options.gapPct, options.intron_window, options.K, options.splice_type_list, options.scoreSplice_window, options.dnaOffset, options.mismatchScore, options.reverse, options.matchScore, options.W, options.X); return 1; } /* read seq1 */ init_seq(argv[optind], &seq1); if (get_next_seq(&seq1, options.dnaOffset, 1) != 0) fatal("Cannot read sequence from %s.\n", argv[optind]); strncpy(dna_seq_head, seq1.header, 256); /* read seq2 */ init_seq(argv[optind + 1], &seq2); if (get_next_seq(&seq2, 0, 0) != 0) fatal("Cannot read sequence from %s.\n", argv[optind + 1]); init_encoding(); init_hash_env(&he, options.W, seq1.seq, seq1.len); init_col(&res, 1); init_col(&rev_res, 1); bld_table(&he); init_splice_junctions(); count = 0; while (!count || get_next_seq(&seq2, 0, 0) == 0) { unsigned int curRes; strncpy(rna_seq_head, seq2.header, 256); ++count; switch (options.reverse) { case 0: SIM4(&he, &seq2, &res); break; case 2: SIM4(&he, &seq2, &res); case 1: seq_revcomp_inplace(&seq2); SIM4(&he, &seq2, &rev_res); break; default: fatal ("Unrecognized request for EST orientation.\n"); } /* Keep only the best matches, according to filterPct. */ if (options.filterPct > 0) { unsigned int max_nmatches = 0; for (curRes = 0; curRes < rev_res.nb; curRes++) { result_p_t r = rev_res.e.result[curRes]; if (r->st.nmatches > max_nmatches) max_nmatches = r->st.nmatches; } for (curRes = 0; curRes < res.nb; curRes++) { result_p_t r = res.e.result[curRes]; if (r->st.nmatches > max_nmatches) max_nmatches = r->st.nmatches; } max_nmatches = (max_nmatches * options.filterPct) / 100; for (curRes = 0; curRes < rev_res.nb; curRes++) { result_p_t r = rev_res.e.result[curRes]; if (r->st.nmatches < max_nmatches) r->st.nmatches = 0; } for (curRes = 0; curRes < res.nb; curRes++) { result_p_t r = res.e.result[curRes]; if (r->st.nmatches < max_nmatches) r->st.nmatches = 0; } } /* Now, print results. */ for (curRes = 0; curRes < rev_res.nb; curRes++) print_res(rev_res.e.result[curRes], 1, &seq1, &seq2); rev_res.nb = 0; if (options.reverse && options.ali_flag) /* reverse-complement back seq2 for alignment */ seq_revcomp_inplace(&seq2); for (curRes = 0; curRes < res.nb; curRes++) print_res(res.e.result[curRes], 0, &seq1, &seq2); res.nb = 0; } #ifdef DEBUG fprintf(stderr, "DEBUG mode: freeing all memory...\n"); fflush(stdout); fflush(stderr); free_hash_env(&he); free_seq(&seq1); free_seq(&seq2); free(options.splice); free(res.e.elt); free(rev_res.e.elt); #endif return 0; }
void main (int argc, char *argv[]) { char c, *p, *name = argv[0]; extern char *optarg; /* getopt stuff */ extern int optind; /* getopt stuff */ int errors = 0; int daemon = 0; char *port = "ricd"; char *rib_file = NULL; int kernel_read_flag = 1; int kernel_install_flag4 = 1; int kernel_install_flag6 = 1; int rib_install_flag = 1; char *usage = "Usage: %s [-f config_file] [-p uii_port ] [-v] [-n]\n"; char *config_file = NULL; trace_t *default_trace; if ((p = strrchr (name, '/')) != NULL) { name = p + 1; } if (strcasecmp (name, "ricd") == 0 || strcasecmp (name, "ricd.purify") == 0) { config_file = "/etc/ricd.conf"; /* unix convension */ daemon = 1; } #ifdef MCHECK mcheck (0); #endif default_trace = New_Trace2 ("RICd"); set_trace (default_trace, TRACE_PREPEND_STRING, "RICD", 0); set_trace (default_trace, TRACE_MAX_ERRORS, DEFAULT_MAX_ERRORS, 0); /* set_trace (default_trace, TRACE_FLAGS, TR_ALL, 0); */ while ((c = getopt (argc, argv, "46rhnkvf:p:l:i:")) != -1) switch (c) { case 'v': /* verbose */ set_trace (default_trace, TRACE_FLAGS, TR_ALL, TRACE_LOGFILE, "stdout", 0); daemon = 0; break; case 'f': /* config file */ config_file = optarg; break; case '4': kernel_install_flag4 = 0; break; case '6': kernel_install_flag6 = 0; break; case 'n': /* no kernel installation */ kernel_install_flag4 = 0; kernel_install_flag6 = 0; daemon = 0; break; case 'k': /* no kernel read */ kernel_read_flag = 0; break; case 'r': /* no rib installation */ rib_install_flag = 0; break; case 'p': /* uii port number */ port = optarg; break; case 'l': /* load rib on disk (mainly for testing) */ case 'i': /* load rib on disk (mainly for testing) */ rib_file = optarg; break; case 'h': default: errors++; break; } if (errors) { fprintf (stderr, usage, name); printf ("\nMRT %s compiled on %s\n\n", RICD_VERSION, __DATE__); exit (1); } #ifdef notdef if (getuid ()) { fprintf (stderr, "must be root\n"); exit (1); } #endif /* init_trace (name, daemon); */ init_trace (name, 1); /* always syslog */ /* no thread creates here */ init_mrt (default_trace); init_uii (default_trace); init_uii_port (port); init_mrt_reboot (argc, argv); trace (TR_INFO, MRT->trace, "%s compiled on %s started\n", MRT->version, MRT->date); if (daemon) { /* * Now going into daemon mode */ MRT->daemon_mode = 1; daemonize (); } /* read information on all interfaces from the kernel */ init_interfaces (default_trace); init_mrtd_config (default_trace); ricd_init (default_trace, AF_INET); #ifdef HAVE_IPV6 ricd_init (default_trace, AF_INET6); #endif /* HAVE_IPV6 */ set_uii (UII, UII_PROMPT, UII_UNPREV, "Password: "******"RICD> ", 0); kernel_init (); /* open routing socket */ /* * read configuration here */ ricd_init_config (); /* default_trace may be modified by debug statement in config file */ if (config_from_file (default_trace, config_file) < 0) { config_create_default (); } /* CONFIGURATION DEPENDENT INITIALIZATION PART */ ricd_start (AF_INET); #ifdef HAVE_IPV6 ricd_start (AF_INET6); #endif /* HAVE_IPV6 */ listen_uii2 (NULL); if (daemon) { int status = 0; if (write (channel[1], &status, sizeof (int)) < 0) perror ("write"); } /* timers never fire until going into loop */ /* select never fire until going into loop */ mrt_main_loop (); exit (0); }
void SweepGenblock::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int state) { if (dmrginp.outputlevel() > 0) mcheck("at the start of block and decimate"); // figure out if we are going forward or backwards pout << "\t\t\t Performing Blocking"<<endl; dmrginp.guessgenT -> start(); bool forward = (system.get_sites() [0] == 0); SpinBlock systemDot; int systemDotStart, systemDotEnd; int systemDotSize = sweepParams.get_sys_add() - 1; if (forward) { systemDotStart = *system.get_sites().rbegin () + 1; systemDotEnd = systemDotStart + systemDotSize; } else { systemDotStart = system.get_sites() [0] - 1; systemDotEnd = systemDotStart - systemDotSize; } vector<int> spindotsites(2); spindotsites[0] = systemDotStart; spindotsites[1] = systemDotEnd; systemDot = SpinBlock(systemDotStart, systemDotEnd); const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size(); system.addAdditionalCompOps(); InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, sweepParams.get_sys_add(), dmrginp.direct(), DISTRIBUTED_STORAGE, dot_with_sys, true); pout << "\t\t\t System Block"<<newSystem; if (dmrginp.outputlevel() > 0) newSystem.printOperatorSummary(); std::vector<Matrix> rotateMatrix; if (!dmrginp.get_fullrestart()) { //this should be done when we actually have wavefunctions stored, otherwise not!! SpinBlock environment, environmentDot, newEnvironment; int environmentDotStart, environmentDotEnd, environmentStart, environmentEnd; InitBlocks::InitNewEnvironmentBlock(environment, systemDot, newEnvironment, system, systemDot, sweepParams.get_sys_add(), sweepParams.get_env_add(), forward, dmrginp.direct(), sweepParams.get_onedot(), nexact, useSlater, true, true, true); SpinBlock big; InitBlocks::InitBigBlock(newSystem, newEnvironment, big); DiagonalMatrix e; std::vector<Wavefunction> solution(1); GuessWave::guess_wavefunctions(solution[0], e, big, sweepParams.get_guesstype(), true, state, true, 0.0); solution[0].SaveWavefunctionInfo (big.get_stateInfo(), big.get_leftBlock()->get_sites(), state); DensityMatrix tracedMatrix; tracedMatrix.allocate(newSystem.get_stateInfo()); tracedMatrix.makedensitymatrix(solution, big, std::vector<double>(1, 1.0), 0.0, 0.0, false); rotateMatrix.clear(); if (!mpigetrank()) double error = newSystem.makeRotateMatrix(tracedMatrix, rotateMatrix, sweepParams.get_keep_states(), sweepParams.get_keep_qstates()); } else LoadRotationMatrix (newSystem.get_sites(), rotateMatrix, state); #ifndef SERIAL mpi::communicator world; broadcast(world, rotateMatrix, 0); #endif if (!dmrginp.get_fullrestart()) SaveRotationMatrix (newSystem.get_sites(), rotateMatrix, state); pout <<"\t\t\t Performing Renormalization "<<endl<<endl; newSystem.transform_operators(rotateMatrix); if (dmrginp.outputlevel() > 0) mcheck("after rotation and transformation of block"); if (dmrginp.outputlevel() > 0) pout <<newSystem<<endl; if (dmrginp.outputlevel() > 0) newSystem.printOperatorSummary(); //mcheck("After renorm transform"); }
static void DEFUN_VOID (turn_on_mcheck) { mcheck (NULL); }
void SweepGenblock::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int stateA, int stateB) { if (dmrginp.outputlevel() > 0) mcheck("at the start of block and decimate"); pout << "\t\t\t Performing Blocking"<<endl; dmrginp.guessgenT -> start(); // figure out if we are going forward or backwards bool forward = (system.get_sites() [0] == 0); SpinBlock systemDot; int systemDotStart, systemDotEnd; int systemDotSize = sweepParams.get_sys_add() - 1; if (forward) { systemDotStart = dmrginp.spinAdapted() ? *system.get_sites().rbegin () + 1 : (*system.get_sites().rbegin ())/2 + 1 ; systemDotEnd = systemDotStart + systemDotSize; } else { systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ; systemDotEnd = systemDotStart - systemDotSize; } vector<int> spindotsites(2); spindotsites[0] = systemDotStart; spindotsites[1] = systemDotEnd; systemDot = SpinBlock(systemDotStart, systemDotEnd, stateA==stateB); const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size(); system.addAdditionalCompOps(); InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, stateA, stateB, sweepParams.get_sys_add(), dmrginp.direct(), DISTRIBUTED_STORAGE, dot_with_sys, true); pout << "\t\t\t System Block"<<newSystem; if (dmrginp.outputlevel() > 0) newSystem.printOperatorSummary(); std::vector<Matrix> leftrotateMatrix, rightrotateMatrix; LoadRotationMatrix (newSystem.get_sites(), leftrotateMatrix, stateA); LoadRotationMatrix (newSystem.get_sites(), rightrotateMatrix, stateB); #ifndef SERIAL mpi::communicator world; broadcast(world, leftrotateMatrix, 0); broadcast(world, rightrotateMatrix, 0); #endif pout <<"\t\t\t Performing Renormalization "<<endl<<endl; if (stateB == stateA) newSystem.transform_operators(leftrotateMatrix); else newSystem.transform_operators(leftrotateMatrix, rightrotateMatrix); if (dmrginp.outputlevel() > 0) //mcheck("after rotation and transformation of block"); if (dmrginp.outputlevel() > 0) pout <<newSystem<<endl; if (dmrginp.outputlevel() > 0) newSystem.printOperatorSummary(); //mcheck("After renorm transform"); }
void SpinAdapted::InitBlocks::InitNewOverlapEnvironmentBlock(SpinBlock &environment, SpinBlock& environmentDot, SpinBlock &newEnvironment, const SpinBlock &system, SpinBlock &systemDot, int leftState, int rightState, const int &sys_add, const int &env_add, const bool &forward, int integralIndex, const bool &onedot, const bool& dot_with_sys, int constraint) { // now initialise environment Dot int systemDotStart, systemDotEnd, environmentDotStart, environmentDotEnd, environmentStart, environmentEnd; int systemDotSize = sys_add - 1; int environmentDotSize = env_add - 1; if (forward) { systemDotStart = dmrginp.spinAdapted() ? *system.get_sites().rbegin () + 1 : (*system.get_sites().rbegin ())/2 + 1 ; systemDotEnd = systemDotStart + systemDotSize; environmentDotStart = systemDotEnd + 1; environmentDotEnd = environmentDotStart + environmentDotSize; environmentStart = environmentDotEnd + 1; environmentEnd = dmrginp.spinAdapted() ? dmrginp.last_site() - 1 : dmrginp.last_site()/2 - 1; } else { systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ; systemDotEnd = systemDotStart - systemDotSize; environmentDotStart = systemDotEnd - 1; environmentDotEnd = environmentDotStart - environmentDotSize; environmentStart = environmentDotEnd - 1; environmentEnd = 0; } std::vector<int> environmentSites; environmentSites.resize(abs(environmentEnd - environmentStart) + 1); for (int i = 0; i < abs(environmentEnd - environmentStart) + 1; ++i) *(environmentSites.begin () + i) = min(environmentStart,environmentEnd) + i; p2out << "\t\t\t Restoring block of size " << environmentSites.size () << " from previous iteration" << endl; if(dot_with_sys && onedot) { newEnvironment.set_integralIndex() = integralIndex; SpinBlock::restore (!forward, environmentSites, newEnvironment, leftState, rightState); } else { environment.set_integralIndex() = integralIndex; SpinBlock::restore (!forward, environmentSites, environment, leftState, rightState); } if (dmrginp.outputlevel() > 0) mcheck(""); // now initialise newEnvironment if (!dot_with_sys || !onedot) { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.initialise_op_array(OVERLAP, false); //newEnvironment.set_op_array(OVERLAP) = boost::shared_ptr<Op_component<Overlap> >(new Op_component<Overlap>(false)); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildSumBlock (constraint, environment, environmentDot); p2out << "\t\t\t Environment block " << endl << environment << endl; environment.printOperatorSummary(); p2out << "\t\t\t NewEnvironment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } else { p2out << "\t\t\t Environment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } }
int main (int argc, char *argv[]) { errcode_t retval = 0, retval2 = 0, orig_retval = 0; int exit_value = FSCK_OK; ext2_filsys fs = 0; io_manager io_ptr; struct ext2_super_block *sb; const char *lib_ver_date; int my_ver, lib_ver; e2fsck_t ctx; blk_t orig_superblock; struct problem_context pctx; int flags, run_result; int journal_size; int sysval, sys_page_size = 4096; __u32 features[3]; char *cp; klog_init(); E2F_DBG_INFO("e2fsck start..."); #ifdef E2FSCK_PIPE_DEBUG_ memset(pipe_msg_temp, 0, MSG_LEN); memcpy(pipe_msg_temp, argv[2], strlen(argv[2])); pipe_open(); pipe_write(C_IN_START); #endif clear_problem_context(&pctx); #ifdef MTRACE mtrace(); #endif #ifdef MCHECK mcheck(0); #endif #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); setlocale(LC_CTYPE, ""); bindtextdomain(NLS_CAT_NAME, LOCALEDIR); textdomain(NLS_CAT_NAME); #endif my_ver = ext2fs_parse_version_string(my_ver_string); lib_ver = ext2fs_get_library_version(0, &lib_ver_date); if (my_ver > lib_ver) { fprintf( stderr, _("Error: ext2fs library version " "out of date!\n")); show_version_only++; } retval = PRS(argc, argv, &ctx); if (retval) { com_err("e2fsck", retval, _("while trying to initialize program")); exit(FSCK_ERROR); } reserve_stdio_fds(); init_resource_track(&ctx->global_rtrack, NULL); if (!(ctx->options & E2F_OPT_PREEN) || show_version_only) fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string, my_ver_date); if (show_version_only) { fprintf(stderr, _("\tUsing %s, %s\n"), error_message(EXT2_ET_BASE), lib_ver_date); exit(FSCK_OK); } check_mount(ctx); if (!(ctx->options & E2F_OPT_PREEN) && !(ctx->options & E2F_OPT_NO) && !(ctx->options & E2F_OPT_YES)) { if (!ctx->interactive) fatal_error(ctx, _("need terminal for interactive repairs")); } ctx->superblock = ctx->use_superblock; restart: #ifdef CONFIG_TESTIO_DEBUG if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) { io_ptr = test_io_manager; test_io_backing_manager = unix_io_manager; } else #endif io_ptr = unix_io_manager; flags = EXT2_FLAG_NOFREE_ON_ERROR; if ((ctx->options & E2F_OPT_READONLY) == 0) flags |= EXT2_FLAG_RW; if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0) flags |= EXT2_FLAG_EXCLUSIVE; retval = try_open_fs(ctx, flags, io_ptr, &fs); if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && !(ctx->flags & E2F_FLAG_SB_SPECIFIED) && ((retval == EXT2_ET_BAD_MAGIC) || (retval == EXT2_ET_CORRUPT_SUPERBLOCK) || ((retval == 0) && (retval2 = ext2fs_check_desc(fs))))) { if (retval2 == ENOMEM) { retval = retval2; goto failure; } if (fs->flags & EXT2_FLAG_NOFREE_ON_ERROR) { ext2fs_free(fs); fs = NULL; } if (!fs || (fs->group_desc_count > 1)) { printf(_("%s: %s trying backup blocks...\n"), ctx->program_name, retval ? _("Superblock invalid,") : _("Group descriptors look bad...")); orig_superblock = ctx->superblock; get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr); if (fs) ext2fs_close(fs); orig_retval = retval; retval = try_open_fs(ctx, flags, io_ptr, &fs); if ((orig_retval == 0) && retval != 0) { if (fs) ext2fs_close(fs); com_err(ctx->program_name, retval, "when using the backup blocks"); printf(_("%s: going back to original " "superblock\n"), ctx->program_name); ctx->superblock = orig_superblock; retval = try_open_fs(ctx, flags, io_ptr, &fs); } } } if (((retval == EXT2_ET_UNSUPP_FEATURE) || (retval == EXT2_ET_RO_UNSUPP_FEATURE)) && fs && fs->super) { sb = fs->super; features[0] = (sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP); features[1] = (sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP); features[2] = (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP); if (features[0] || features[1] || features[2]) goto print_unsupp_features; } failure: if (retval) { if (orig_retval) retval = orig_retval; com_err(ctx->program_name, retval, _("while trying to open %s"), ctx->filesystem_name); if (retval == EXT2_ET_REV_TOO_HIGH) { printf(_("The filesystem revision is apparently " "too high for this version of e2fsck.\n" "(Or the filesystem superblock " "is corrupt)\n\n")); fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); } else if (retval == EXT2_ET_SHORT_READ) printf(_("Could this be a zero-length partition?\n")); else if ((retval == EPERM) || (retval == EACCES)) printf(_("You must have %s access to the " "filesystem or be root\n"), (ctx->options & E2F_OPT_READONLY) ? "r/o" : "r/w"); else if (retval == ENXIO) printf(_("Possibly non-existent or swap device?\n")); else if (retval == EBUSY) printf(_("Filesystem mounted or opened exclusively " "by another program?\n")); else if (retval == ENOENT) printf(_("Possibly non-existent device?\n")); #ifdef EROFS else if (retval == EROFS) printf(_("Disk write-protected; use the -n option " "to do a read-only\n" "check of the device.\n")); #endif else fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); fatal_error(ctx, 0); } /* * We only update the master superblock because (a) paranoia; * we don't want to corrupt the backup superblocks, and (b) we * don't need to update the mount count and last checked * fields in the backup superblock (the kernel doesn't update * the backup superblocks anyway). With newer versions of the * library this flag is set by ext2fs_open2(), but we set this * here just to be sure. (No, we don't support e2fsck running * with some other libext2fs than the one that it was shipped * with, but just in case....) */ fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; if (!(ctx->flags & E2F_FLAG_GOT_DEVSIZE)) { __u32 blocksize = EXT2_BLOCK_SIZE(fs->super); int need_restart = 0; pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name, blocksize, &ctx->num_blocks); /* * The floppy driver refuses to allow anyone else to * open the device if has been opened with O_EXCL; * this is unlike other block device drivers in Linux. * To handle this, we close the filesystem and then * reopen the filesystem after we get the device size. */ if (pctx.errcode == EBUSY) { ext2fs_close(fs); need_restart++; pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name, blocksize, &ctx->num_blocks); } if (pctx.errcode == EXT2_ET_UNIMPLEMENTED) ctx->num_blocks = 0; else if (pctx.errcode) { fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; fatal_error(ctx, 0); } ctx->flags |= E2F_FLAG_GOT_DEVSIZE; if (need_restart) goto restart; } ctx->fs = fs; fs->priv_data = ctx; fs->now = ctx->now; sb = fs->super; if (sb->s_rev_level > E2FSCK_CURRENT_REV) { com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH, _("while trying to open %s"), ctx->filesystem_name); get_newer: fatal_error(ctx, _("Get a newer version of e2fsck!")); } /* * Set the device name, which is used whenever we print error * or informational messages to the user. */ if (ctx->device_name == 0 && (sb->s_volume_name[0] != 0)) { ctx->device_name = string_copy(ctx, sb->s_volume_name, sizeof(sb->s_volume_name)); } if (ctx->device_name == 0) ctx->device_name = string_copy(ctx, ctx->filesystem_name, 0); for (cp = ctx->device_name; *cp; cp++) if (isspace(*cp) || *cp == ':') *cp = '_'; ehandler_init(fs->io); if ((ctx->mount_flags & EXT2_MF_MOUNTED) && !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER)) goto skip_journal; /* * Make sure the ext3 superblock fields are consistent. */ retval = e2fsck_check_ext3_journal(ctx); if (retval) { com_err(ctx->program_name, retval, _("while checking ext3 journal for %s"), ctx->device_name); fatal_error(ctx, 0); } /* * Check to see if we need to do ext3-style recovery. If so, * do it, and then restart the fsck. */ if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) { if (ctx->options & E2F_OPT_READONLY) { printf(_("Warning: skipping journal recovery " "because doing a read-only filesystem " "check.\n")); io_channel_flush(ctx->fs->io); } else { if (ctx->flags & E2F_FLAG_RESTARTED) { /* * Whoops, we attempted to run the * journal twice. This should never * happen, unless the hardware or * device driver is being bogus. */ com_err(ctx->program_name, 0, _("unable to set superblock flags on %s\n"), ctx->device_name); fatal_error(ctx, 0); } retval = e2fsck_run_ext3_journal(ctx); if (retval) { com_err(ctx->program_name, retval, _("while recovering ext3 journal of %s"), ctx->device_name); fatal_error(ctx, 0); } ext2fs_close(ctx->fs); ctx->fs = 0; ctx->flags |= E2F_FLAG_RESTARTED; goto restart; } } skip_journal: /* * Check for compatibility with the feature sets. We need to * be more stringent than ext2fs_open(). */ features[0] = sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP; features[1] = sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP; features[2] = (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP); print_unsupp_features: if (features[0] || features[1] || features[2]) { int i, j; __u32 *mask = features, m; fprintf(stderr, _("%s has unsupported feature(s):"), ctx->filesystem_name); for (i=0; i <3; i++,mask++) { for (j=0,m=1; j < 32; j++, m<<=1) { if (*mask & m) fprintf(stderr, " %s", e2p_feature2string(i, m)); } } putc('\n', stderr); goto get_newer; } #ifdef ENABLE_COMPRESSION if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION) com_err(ctx->program_name, 0, _("Warning: compression support is experimental.\n")); #endif #ifndef ENABLE_HTREE if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) { com_err(ctx->program_name, 0, _("E2fsck not compiled with HTREE support,\n\t" "but filesystem %s has HTREE directories.\n"), ctx->device_name); goto get_newer; } #endif /* * If the user specified a specific superblock, presumably the * master superblock has been trashed. So we mark the * superblock as dirty, so it can be written out. */ if (ctx->superblock && !(ctx->options & E2F_OPT_READONLY)) ext2fs_mark_super_dirty(fs); /* * Calculate the number of filesystem blocks per pagesize. If * fs->blocksize > page_size, set the number of blocks per * pagesize to 1 to avoid division by zero errors. */ #ifdef _SC_PAGESIZE sysval = sysconf(_SC_PAGESIZE); if (sysval > 0) sys_page_size = sysval; #endif /* _SC_PAGESIZE */ ctx->blocks_per_page = sys_page_size / fs->blocksize; if (ctx->blocks_per_page == 0) ctx->blocks_per_page = 1; if (ctx->superblock) set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); ext2fs_mark_valid(fs); check_super_block(ctx); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); check_if_skip(ctx); check_resize_inode(ctx); if (bad_blocks_file) read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks); else if (cflag) read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */ if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); /* * Mark the system as valid, 'til proven otherwise */ ext2fs_mark_valid(fs); retval = ext2fs_read_bb_inode(fs, &fs->badblocks); if (retval) { com_err(ctx->program_name, retval, _("while reading bad blocks inode")); preenhalt(ctx); printf(_("This doesn't bode well," " but we'll try to go on...\n")); } /* * Save the journal size in megabytes. * Try and use the journal size from the backup else let e2fsck * find the default journal size. */ if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) journal_size = sb->s_jnl_blocks[16] >> 20; else
void main(int argc,String *argv) { mcheck(); randomise(); a=ArgParser(argc,argv); nnname=a.argafter("-nn","nn name","current.net"); tsname=a.argafter("-ts","trainset name","current.pat"); eacq=a.intafter("-eqcq","Edge Angle Cancelling histogram quantisation",16); eacrad=a.intafter("-eacrad","Default radius for eac",6); glq=a.intafter("-glq","greylevel quantisation",32); glhistrad=a.intafter("-glvr","Default radius for gl variance",3); windres=a.intafter("-wskip","pixel skip for window segmentation",5); botres=a.intafter("-br","bottom res for neighbour segmenter (botres*2^n=topres)",2); topres=a.intafter("-tr","top res",32); notext=a.floatafter("-nt","not text if < than",-4.5); istext=a.floatafter("-it","is text if > than",-2.0); show=a.argexists("-show","show results of measures"); usenumpostrainexs=a.intafter("-nptes","number of positive training examples to output",50); usenumnegtrainexs=a.intafter("-nntes","number of positive training examples to output",50); scale=a.floatafter("-s","scale",0.5); morphrad=a.intafter("-mr","radius for morphology",3); twooutnodes=true; // a.argexists("-to","two output nodes"); minarea=a.intafter("-ms","minimum size of kept region",200); // ghistscale=a.floatafter("-ghs","scale for hist stability",0.5); a.opts.add("task = trainset | newnn | trainnn | scan | test"); String task=a.arg("task"); if (Seq(task,"trainset")) { a.opts.add("trainset task = new | image | finish"); String task2=a.arg("trainset task"); if (Seq(task2,"new")) { tsname=a.argor(tsname); a.done(); makenewtrainingset(); } else if (Seq(task2,"image")) { iname=a.arg("image file"); a.done(); trainimage(); } else if(Seq(task2,"finish")) { a.done(); finishtrainingset(); } else { a.done(); error("Please choose a task for the training set"); } } else if (Seq(task,"newnn")) { a.opts.add("nn type = hopfield | banana"); String type=a.arg("nn type"); a.done(); makenewnn(type); } else if (Seq(task,"trainnn")) { a.done(); trainnetwork(); } else if (Seq(task,"scan")) { iname=a.arg("image file"); a.done(); scanimage(); } else if (Seq(task,"test")) { iname=a.arg("image file"); a.done(); testimage(); } else { a.done(); error("Please choose a task."); } printf("jnn : Finished.\n");