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);
}
