int main(void) { mp_time_init(); struct ctx *k = malloc(sizeof(struct ctx)); int64_t s = mp_time_us(); makegauss(k, 6); makeuniform(k); print(k); fsck(k); int64_t l = mp_time_us() - s; printf("time: %f ms\n", l / 1000.0); return 0; }
int main(int argc, char** argv) { char* devicepath; disk_format_t df; int r; fsck_options_t options = default_fsck_options; if ((r = parse_args(argc, argv, &options, &df, &devicepath))) { return r; } if (options.verbose) { printf("fs_fsck: Checking device [%s]\n", devicepath); } if ((r = fsck(devicepath, df, &options, launch_stdio_sync)) < 0) { fprintf(stderr, "fs_fsck: Failed to check device: %d\n", r); } return r; }
int main(int argc, char* argv[]) { int opt; const char* spec = NULL; struct exfat ef; printf("exfatfsck %u.%u.%u\n", EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH); while ((opt = getopt(argc, argv, "V")) != -1) { switch (opt) { case 'V': puts("Copyright (C) 2011-2013 Andrew Nayenko"); return 0; default: usage(argv[0]); break; } } if (argc - optind != 1) usage(argv[0]); spec = argv[optind]; if (exfat_mount(&ef, spec, "ro") != 0) return 1; printf("Checking file system on %s.\n", spec); fsck(&ef); exfat_unmount(&ef); printf("Totally %"PRIu64" directories and %"PRIu64" files.\n", directories_count, files_count); fputs("File system checking finished. ", stdout); if (exfat_errors != 0) { printf("ERRORS FOUND: %d.\n", exfat_errors); return 1; } puts("No errors found."); return 0; }
bool Fs::mount(void) { /* already mounted */ if (this->files_opened > 1) return OSAL_SUCCESS; /* check file table correctness*/ if (OSAL_FAILED == fsck()) goto FAILED; open_super(); this->files_opened = 1; return OSAL_SUCCESS; FAILED: this->files_opened = 0; super.close(); return OSAL_FAILED; }
static pid_t begin_mount(const char* mnt, struct blockdevice* bdev) { struct filesystem* fs = bdev->fs; if ( !fs ) return -1; if ( !fs->driver ) return -1; if ( fs->flags & FILESYSTEM_FLAG_FSCK_MUST && !fsck(fs) ) return -1; struct stat fs_oldstat; if ( stat(mnt, &fs_oldstat) < 0 ) { warn("stat: %s", mnt); return -1; } const char* bdev_path = path_of_blockdevice(fs->bdev); pid_t fs_pid = fork(); if ( fs_pid < 0 ) { warn("fork"); return -1; } if ( fs_pid == 0 ) { setpgid(0, 0); const char* argv[] = { fs->driver, "--foreground", bdev_path, mnt, NULL }; execvp(argv[0], (char* const*) argv); warn("%s", argv[0]); _exit(127); } if ( !await_mount(mnt, fs_pid, &fs_oldstat, bdev_path, fs->driver) ) return false; return fs_pid; }
static int checkdir(long a, long qpath) { Dentry *nd; int i, ns, dmod; ns = strlen(name); dmod = touch(a); for(i=0; i<DIRPERBUF; i++) { nd = maked(a, i, qpath); if(!nd) break; if(fsck(nd)) { modd(a, i, nd); dmod++; } depth--; fence -= sizeof(Dentry); name[ns] = 0; } name[ns] = 0; return dmod; }
int exfatfsck_main(int argc, char* argv[]) { int opt; const char* spec = NULL; struct exfat ef; bool do_fix = false; printf("exfatfsck %u.%u.%u\n", EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH); while ((opt = getopt(argc, argv, "Vf")) != -1) { switch (opt) { case 'V': puts("Copyright (C) 2011-2014 Andrew Nayenko"); return 0; case 'f': do_fix = true; break; default: usage(argv[0]); break; } } if (argc - optind != 1) usage(argv[0]); spec = argv[optind]; if (exfat_mount(&ef, spec, "ro") != 0) return 1; printf("Checking file system on %s.\n", spec); fsck(&ef); printf("Totally %"PRIu64" directories and %"PRIu64" files.\n", directories_count, files_count); puts("File system checking finished."); if ( do_fix && exfat_errors == 0 && (le16_to_cpu(ef.sb->volume_state) & EXFAT_STATE_MOUNTED) != 0 ) { puts("Closing the volume..."); exfat_unmount(&ef); if ( exfat_mount(&ef, spec, "rw") != 0 ) { puts("Failed to mount for writing!"); puts("No errors found."); return 0; } ef.was_dirty = false; // The following unmount will clear EXFAT_STATE_MOUNTED! puts("Done!"); } exfat_unmount(&ef); if ( exfat_errors != 0 ) { printf("ERRORS FOUND: %d.\n", exfat_errors); return 1; } puts("No errors found."); return 0; }
int main(int argc, char* argv[]) { char *path; char cmd[256]; int udev = 0; uev_t timer; /* Bootstrap timer, on timeout call finalize() */ uev_ctx_t loop; /* * finit/init/telinit client tool uses /dev/initctl pipe * for compatibility but initctl client tool uses socket */ if (getpid() != 1) return client(argc, argv); /* * Initalize event context. */ uev_init(&loop); ctx = &loop; /* * Set PATH and SHELL early to something sane */ setenv("PATH", _PATH_STDPATH, 1); setenv("SHELL", _PATH_BSHELL, 1); /* * Mount base file system, kernel is assumed to run devtmpfs for /dev */ chdir("/"); umask(0); mount("none", "/proc", "proc", 0, NULL); mount("none", "/sys", "sysfs", 0, NULL); if (fisdir("/proc/bus/usb")) mount("none", "/proc/bus/usb", "usbfs", 0, NULL); /* * Parse kernel command line (debug, rescue, splash, etc.) * Also calls log_init() to set correct log level */ conf_parse_cmdline(); /* Set up canvas */ if (!rescue && !log_is_debug()) screen_init(); /* * In case of emergency. */ emergency_shell(); /* * Initial setup of signals, ignore all until we're up. */ sig_init(); /* * Load plugins early, finit.conf may contain references to * features implemented by plugins. */ plugin_init(&loop); /* * Hello world. */ banner(); /* * Check file filesystems in /etc/fstab */ for (int pass = 1; pass < 10 && !rescue; pass++) { if (fsck(pass)) break; } /* * Initialize .conf system and load static /etc/finit.conf * Also initializes global_rlimit[] for udevd, below. */ conf_init(); /* * Some non-embedded systems without an initramfs may not have /dev mounted yet * If they do, check if system has udevadm and perform cleanup from initramfs */ if (!fismnt("/dev")) mount("udev", "/dev", "devtmpfs", MS_RELATIME, "size=10%,nr_inodes=61156,mode=755"); else if (whichp("udevadm")) run_interactive("udevadm info --cleanup-db", "Cleaning up udev db"); /* Some systems use /dev/pts */ makedir("/dev/pts", 0755); mount("devpts", "/dev/pts", "devpts", 0, "gid=5,mode=620"); /* * Some systems rely on us to both create /dev/shm and, to mount * a tmpfs there. Any system with dbus needs shared memory, so * mount it, unless its already mounted, but not if listed in * the /etc/fstab file already. */ makedir("/dev/shm", 0755); if (!fismnt("/dev/shm") && !ismnt("/etc/fstab", "/dev/shm")) mount("shm", "/dev/shm", "tmpfs", 0, NULL); /* * New tmpfs based /run for volatile runtime data * For details, see http://lwn.net/Articles/436012/ */ if (fisdir("/run") && !fismnt("/run")) mount("tmpfs", "/run", "tmpfs", MS_NODEV, "mode=0755,size=10%"); umask(022); /* Bootstrap conditions, needed for hooks */ cond_init(); /* * Populate /dev and prepare for runtime events from kernel. * Prefer udev if mdev is also available on the system. */ path = which("udevd"); if (!path) path = which("/lib/systemd/systemd-udevd"); if (path) { /* Desktop and server distros usually have a variant of udev */ udev = 1; /* Register udevd as a monitored service */ snprintf(cmd, sizeof(cmd), "[S12345789] pid:udevd %s -- Device event managing daemon", path); if (service_register(SVC_TYPE_SERVICE, cmd, global_rlimit, NULL)) { _pe("Failed registering %s", path); udev = 0; } else { snprintf(cmd, sizeof(cmd), ":1 [S] <svc%s> " "udevadm trigger -c add -t devices " "-- Requesting device events", path); service_register(SVC_TYPE_RUN, cmd, global_rlimit, NULL); snprintf(cmd, sizeof(cmd), ":2 [S] <svc%s> " "udevadm trigger -c add -t subsystems " "-- Requesting subsystem events", path); service_register(SVC_TYPE_RUN, cmd, global_rlimit, NULL); } free(path); } else { path = which("mdev"); if (path) { /* Embedded Linux systems usually have BusyBox mdev */ if (log_is_debug()) touch("/dev/mdev.log"); snprintf(cmd, sizeof(cmd), "%s -s", path); free(path); run_interactive(cmd, "Populating device tree"); } } /* * Start built-in watchdog as soon as possible, if enabled */ wdogpid = watchdog(argv[0]); /* * Mount filesystems */ if (!rescue) { #ifdef REMOUNT_ROOTFS run("mount -n -o remount,rw /"); #endif #ifdef SYSROOT mount(SYSROOT, "/", NULL, MS_MOVE, NULL); #endif } if (!rescue) { _d("Root FS up, calling hooks ..."); plugin_run_hooks(HOOK_ROOTFS_UP); umask(0); if (run_interactive("mount -na", "Mounting filesystems")) plugin_run_hooks(HOOK_MOUNT_ERROR); _d("Calling extra mount hook, after mount -a ..."); plugin_run_hooks(HOOK_MOUNT_POST); run("swapon -ea"); umask(0022); } /* Base FS up, enable standard SysV init signals */ sig_setup(&loop); if (!rescue) { _d("Base FS up, calling hooks ..."); plugin_run_hooks(HOOK_BASEFS_UP); } /* * Set up inotify watcher for /etc/finit.d and read all .conf * files to figure out how to bootstrap the system. */ conf_monitor(&loop); /* * Initalize state machine and start all bootstrap tasks * NOTE: no network available! */ sm_init(&sm); sm_step(&sm); /* Debian has this little script to copy generated rules while the system was read-only */ if (udev && fexist("/lib/udev/udev-finish")) run_interactive("/lib/udev/udev-finish", "Finalizing udev"); /* Start new initctl API responder */ api_init(&loop); umask(022); /* * Wait for all SVC_TYPE_RUNTASK to have completed their work in * [S], or timeout, before calling finalize() */ _d("Starting bootstrap finalize timer ..."); uev_timer_init(&loop, &timer, service_bootstrap_cb, finalize, 1000, 1000); /* * Enter main loop to monior /dev/initctl and services */ _d("Entering main loop ..."); return uev_run(&loop, 0); }
int main(int argc, char** argv) { if(argv[1] && strcmp(argv[1], "cli") == 0) { return cli(argc-1, argv+1); } if(argv[1] && strcmp(argv[1], "fsck") == 0) { return fsck(argc-1,argv+1); } bool daemon = false; std::string host = ""; int port=7621; int master_port = -1; std::string data_dir = "harq.db"; int ch = 0; while((ch = getopt(argc, argv, "hDb:p:d:m:")) != -1) { switch(ch) { default: case 'h': std::cout << "Usage:\n\t./harq [options]\n" << "Options:\n" << "\t-D:\t\t daemon\n" << "\t-b host-ip:\t listen host\n" << "\t-p port:\t listen port\n" << "\t-d data-dir:\t data dir\n" << "\t-m master:\t master\n"; exit(0); case 'D': daemon = true; break; case 'b': host = optarg; break; case 'p': port = (int)strtol(optarg, (char **)NULL, 10); if(!port){ printf("Bad port(-p) value\n"); exit(1); } break; case 'd': data_dir = optarg; break; case 'm': master_port = atoi(optarg); break; } } if(daemon) { if(daemon_init() == -1) { printf("can't run as daemon\n"); exit(1); } } // signal(SIGTERM, sig_term); // signal(SIGINT, sig_term); signal(SIGPIPE, SIG_IGN); Config cfg("qadmus.cfg"); /* cfg.open(); if(!cfg.read()) { std::cout << "Config error: " << cfg.error() << "\n"; } cfg.show(); */ Server server(cfg, data_dir, host, port); if(!server.read_queues()) return 1; if(master_port > 0) { server.connect_replica("localhost", master_port); } server.start(); return 0; }
void check(Filsys *fs, long flag) { Iobuf *p; Superb *sb; Dentry *d; long raddr; long nqid; wlock(&mainlock); dev = fs->dev; flags = flag; fence = fencebase; sizname = 4000; name = zalloc(sizname); sizname -= NAMELEN+10; /* for safety */ sbaddr = superaddr(dev); raddr = getraddr(dev); p = xtag(sbaddr, Tsuper, QPSUPER); if(!p){ cprint("bad superblock\n"); goto out; } sb = (Superb*)p->iobuf; fstart = 1; fsize = sb->fsize; sizabits = (fsize-fstart + 7)/8; abits = zalloc(sizabits); nqid = sb->qidgen+100; /* not as much of a botch */ if(nqid > 1024*1024*8) nqid = 1024*1024*8; if(nqid < 64*1024) nqid = 64*1024; sizqbits = (nqid+7)/8; qbits = zalloc(sizqbits); mod = 0; nfree = 0; nfdup = 0; nused = 0; nbad = 0; ndup = 0; nqbad = 0; depth = 0; maxdepth = 0; if(flags & Ctouch) { oldblock = fsize/DSIZE; oldblock *= DSIZE; if(oldblock < 0) oldblock = 0; cprint("oldblock = %ld\n", oldblock); } if(amark(sbaddr)) {} if(cwflag) { if(amark(sb->roraddr)) {} if(amark(sb->next)) {} } if(!(flags & Cquiet)) cprint("checking file system: %s\n", fs->name); nfiles = 0; maxq = 0; d = maked(raddr, 0, QPROOT); if(d) { if(amark(raddr)) {} if(fsck(d)) modd(raddr, 0, d); depth--; fence -= sizeof(Dentry); if(depth) cprint("depth not zero on return\n"); } if(flags & Cfree) { mkfreelist(sb); sb->qidgen = maxq; settag(p, Tsuper, QPNONE); } if(sb->qidgen < maxq) cprint("qid generator low path=%ld maxq=%ld\n", sb->qidgen, maxq); if(!(flags & Cfree)) ckfreelist(sb); if(mod) { cprint("file system was modified\n"); settag(p, Tsuper, QPNONE); } if(!(flags & Cquiet)){ cprint("%8ld files\n", nfiles); cprint("%8ld blocks in the file system\n", fsize-fstart); cprint("%8ld used blocks\n", nused); cprint("%8ld free blocks\n", sb->tfree); } if(!(flags & Cfree)){ if(nfree != sb->tfree) cprint("%8ld free blocks found\n", nfree); if(nfdup) cprint("%8ld blocks duplicated in the free list\n", nfdup); if(fsize-fstart-nused-nfree) cprint("%8ld missing blocks\n", fsize-fstart-nused-nfree); } if(ndup) cprint("%8ld address duplications\n", ndup); if(nbad) cprint("%8ld bad block addresses\n", nbad); if(nqbad) cprint("%8ld bad qids\n", nqbad); if(!(flags & Cquiet)) cprint("%8ld maximum qid path\n", maxq); missing(); out: if(p) putbuf(p); free(abits); free(name); free(qbits); wunlock(&mainlock); }