static error_t
rootdir_gc_cmdline (void *hook, char **contents, ssize_t *contents_len)
{
struct ps_context *pc = hook;
struct proc_stat *ps;
error_t err;
err = _proc_stat_create (opt_kernel_pid, pc, &ps);
if (err)
return EIO;
err = proc_stat_set_flags (ps, PSTAT_ARGS);
if (err || ! (proc_stat_flags (ps) & PSTAT_ARGS))
{
err = EIO;
goto out;
}
*contents_len = proc_stat_args_len (ps);
*contents = malloc (*contents_len);
if (! *contents)
{
err = ENOMEM;
goto out;
}
memcpy (*contents, proc_stat_args (ps), *contents_len);
argz_stringify (*contents, *contents_len, ' ');
(*contents)[*contents_len - 1] = '\n';
out:
_proc_stat_free (ps);
return err;
}
int main (int argc, char *argv[])
{
flux_t h;
int ch;
char *message = NULL;
size_t len = 0;
char *priority = "user.notice";
int level;
char *facility;
int e;
log_init ("flux-logger");
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 'p': /* --priority facility.level */
priority = optarg;
break;
default:
usage ();
break;
}
}
if (optind == argc)
usage ();
if ((e = argz_create (argv + optind, &message, &len)) != 0)
errn_exit (e, "argz_create");
argz_stringify (message, len, ' ');
if (!(h = flux_open (NULL, 0)))
err_exit ("flux_open");
if (parse_logstr (priority, &level, &facility) < 0)
msg_exit ("bad priority argument");
flux_log_set_facility (h, facility);
if (flux_log (h, level, "%s", message) < 0)
err_exit ("flux_log");
flux_close (h);
free (message);
free (facility);
log_fini ();
return 0;
}
int main (int argc, char *argv[])
{
flux_t h;
int ch;
char *message = NULL;
size_t len = 0;
int severity = LOG_NOTICE;
char *appname = "logger";
int e;
log_init ("flux-logger");
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 's': /* --severity LEVEL */
if ((severity = stdlog_string_to_severity (optarg)) < 0)
log_msg_exit ("invalid severity: Use emerg|alert|crit|err|warning|notice|info|debug");
break;
case 'n': /* --appname NAME */
appname = optarg;
break;
default:
usage ();
break;
}
}
if (optind == argc)
usage ();
if ((e = argz_create (argv + optind, &message, &len)) != 0)
log_errn_exit (e, "argz_create");
argz_stringify (message, len, ' ');
if (!(h = flux_open (NULL, 0)))
log_err_exit ("flux_open");
flux_log_set_appname (h, appname);
flux_log (h, severity, "%s", message);
flux_close (h);
free (message);
log_fini ();
return 0;
}
static char* make_command_new(char* dirs[])
{
char* buf = 0;
char* cmdline = 0;
size_t len;
if (argz_create(dirs, &cmdline, &len) == 0) {
argz_stringify(cmdline, len, ' ');
if (asprintf(&buf, "%s %s", "/usr/sbin/lsof -Fn" , cmdline) < 0) {
goto out;
}
}
out:
if (cmdline) {
free(cmdline);
}
return buf;
}
int main(int argc, char **argv) {
int opt;
struct augeas *aug;
char *loadpath = NULL;
size_t loadpathlen = 0;
enum {
VAL_NO_STDINC = CHAR_MAX + 1,
VAL_NO_TYPECHECK = VAL_NO_STDINC + 1,
VAL_VERSION = VAL_NO_TYPECHECK + 1
};
struct option options[] = {
{ "help", 0, 0, 'h' },
{ "include", 1, 0, 'I' },
{ "trace", 0, 0, 't' },
{ "nostdinc", 0, 0, VAL_NO_STDINC },
{ "notypecheck", 0, 0, VAL_NO_TYPECHECK },
{ "version", 0, 0, VAL_VERSION },
{ 0, 0, 0, 0}
};
int idx;
unsigned int flags = AUG_TYPE_CHECK|AUG_NO_MODL_AUTOLOAD;
progname = argv[0];
setlocale(LC_ALL, "");
while ((opt = getopt_long(argc, argv, "hI:t", options, &idx)) != -1) {
switch(opt) {
case 'I':
argz_add(&loadpath, &loadpathlen, optarg);
break;
case 't':
flags |= AUG_TRACE_MODULE_LOADING;
break;
case 'h':
usage();
break;
case VAL_NO_STDINC:
flags |= AUG_NO_STDINC;
break;
case VAL_NO_TYPECHECK:
flags &= ~(AUG_TYPE_CHECK);
break;
case VAL_VERSION:
print_version = true;
break;
default:
usage();
break;
}
}
if (!print_version && optind >= argc) {
fprintf(stderr, "Expected .aug file\n");
usage();
}
argz_stringify(loadpath, loadpathlen, PATH_SEP_CHAR);
aug = aug_init(NULL, loadpath, flags);
if (aug == NULL) {
fprintf(stderr, "Memory exhausted\n");
return 2;
}
if (print_version) {
print_version_info(aug);
return EXIT_SUCCESS;
}
if (__aug_load_module_file(aug, argv[optind]) == -1) {
fprintf(stderr, "%s\n", aug_error_message(aug));
const char *s = aug_error_details(aug);
if (s != NULL) {
fprintf(stderr, "%s\n", s);
}
exit(EXIT_FAILURE);
}
aug_close(aug);
free(loadpath);
}
int main (int argc, char *argv[])
{
flux_t h;
int ch;
uint32_t rank = FLUX_NODEID_ANY; /* local */
char *cmd;
int e;
log_init ("flux-comms");
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 'r': /* --rank N */
rank = strtoul (optarg, NULL, 10);
break;
default:
usage ();
break;
}
}
if (optind == argc)
usage ();
cmd = argv[optind++];
if (rank != FLUX_NODEID_ANY
&& (!strcmp (cmd, "recover-all") || !strcmp (cmd, "info")))
usage ();
if (!(h = flux_open (NULL, 0)))
log_err_exit ("flux_open");
if (!strcmp (cmd, "reparent")) {
if (optind != argc - 1)
usage ();
if (flux_reparent (h, rank, argv[optind]) < 0)
log_err_exit ("flux_reparent");
} else if (!strcmp (cmd, "idle")) {
if (optind != argc)
usage ();
char *peers;
if (!(peers = flux_lspeer (h, rank)))
log_err_exit ("flux_peer");
printf ("%s\n", peers);
free (peers);
} else if (!strcmp (cmd, "panic")) {
char *msg = NULL;
size_t len = 0;
if (optind < argc) {
if ((e = argz_create (argv + optind, &msg, &len)) != 0)
log_errn_exit (e, "argz_create");
argz_stringify (msg, len, ' ');
}
flux_panic (h, rank, msg);
if (msg)
free (msg);
} else if (!strcmp (cmd, "failover")) {
if (optind != argc)
usage ();
if (flux_failover (h, rank) < 0)
log_err_exit ("flux_failover");
} else if (!strcmp (cmd, "recover")) {
if (optind != argc)
usage ();
if (flux_recover (h, rank) < 0)
log_err_exit ("flux_recover");
} else if (!strcmp (cmd, "recover-all")) {
if (optind != argc)
usage ();
if (flux_recover_all (h) < 0)
log_err_exit ("flux_recover_all");
} else if (!strcmp (cmd, "info")) {
int arity;
uint32_t rank, size;
const char *s;
if (flux_get_rank (h, &rank) < 0 || flux_get_size (h, &size) < 0)
log_err_exit ("flux_get_rank/size");
if (!(s = flux_attr_get (h, "tbon.arity", NULL)))
log_err_exit ("flux_attr_get tbon.arity");
arity = strtoul (s, NULL, 10);
printf ("rank=%d\n", rank);
printf ("size=%d\n", size);
printf ("arity=%d\n", arity);
} else
usage ();
flux_close (h);
log_fini ();
return 0;
}
static void parse_opts(int argc, char **argv) {
int opt;
size_t loadpathlen = 0;
enum {
VAL_VERSION = CHAR_MAX + 1,
VAL_SPAN = VAL_VERSION + 1
};
struct option options[] = {
{ "help", 0, 0, 'h' },
{ "typecheck", 0, 0, 'c' },
{ "backup", 0, 0, 'b' },
{ "new", 0, 0, 'n' },
{ "root", 1, 0, 'r' },
{ "include", 1, 0, 'I' },
{ "transform", 1, 0, 't' },
{ "echo", 0, 0, 'e' },
{ "file", 1, 0, 'f' },
{ "autosave", 0, 0, 's' },
{ "interactive", 0, 0, 'i' },
{ "nostdinc", 0, 0, 'S' },
{ "noload", 0, 0, 'L' },
{ "noautoload", 0, 0, 'A' },
{ "span", 0, 0, VAL_SPAN },
{ "version", 0, 0, VAL_VERSION },
{ 0, 0, 0, 0}
};
int idx;
while ((opt = getopt_long(argc, argv, "hnbcr:I:t:ef:siSLA", options, &idx)) != -1) {
switch(opt) {
case 'c':
flags |= AUG_TYPE_CHECK;
break;
case 'b':
flags |= AUG_SAVE_BACKUP;
break;
case 'n':
flags |= AUG_SAVE_NEWFILE;
break;
case 'h':
usage();
break;
case 'r':
root = optarg;
break;
case 'I':
argz_add(&loadpath, &loadpathlen, optarg);
break;
case 't':
argz_add(&transforms, &transformslen, optarg);
break;
case 'e':
echo_commands = 1;
break;
case 'f':
inputfile = optarg;
break;
case 's':
auto_save = true;
break;
case 'i':
interactive = true;
break;
case 'S':
flags |= AUG_NO_STDINC;
break;
case 'L':
flags |= AUG_NO_LOAD;
break;
case 'A':
flags |= AUG_NO_MODL_AUTOLOAD;
break;
case VAL_VERSION:
flags |= AUG_NO_MODL_AUTOLOAD;
print_version = true;
break;
case VAL_SPAN:
flags |= AUG_ENABLE_SPAN;
break;
default:
usage();
break;
}
}
argz_stringify(loadpath, loadpathlen, PATH_SEP_CHAR);
}
/* Starts FS's fsck program on FS's device, returning the pid of the process.
If an error is encountered, prints an error message and returns 0.
Filesystems that need not be fscked at all also return 0 (but don't print
an error message). */
static pid_t
fs_start_fsck (struct fs *fs, int flags)
{
pid_t pid;
char flags_buf[10];
char *argv[4], **argp = argv;
struct fstype *type;
error_t err = fs_type (fs, &type);
assert_perror (err); /* Should already have been checked for. */
assert (type->program);
*argp++ = type->program;
if (flags & (FSCK_F_PREEN|FSCK_F_YES|FSCK_F_NO|FSCK_F_FORCE|FSCK_F_SILENT))
{
char *p = flags_buf;
*argp++ = flags_buf;
*p++ = '-';
if (flags & FSCK_F_PREEN) *p++ = 'p';
if (flags & FSCK_F_YES) *p++ = 'y';
if (flags & FSCK_F_NO) *p++ = 'n';
if (flags & FSCK_F_FORCE) *p++ = 'f';
if (flags & FSCK_F_SILENT) *p++ = 's';
*p = '\0';
}
*argp++ = fs->mntent.mnt_fsname;
*argp = 0;
if (flags & FSCK_F_DRYRUN)
{
char *argz;
size_t argz_len;
argz_create (argv, &argz, &argz_len);
argz_stringify (argz, argz_len, ' ');
puts (argz);
free (argz);
return 0;
}
pid = fork ();
if (pid < 0)
{
error (0, errno, "fork");
return 0;
}
if (pid == 0)
/* Child. */
{
execv (type->program, argv);
exit (FSCK_EX_EXEC); /* Exec failed. */
}
if ((flags & FSCK_F_VERBOSE) || _debug)
{
char *argz;
size_t argz_len;
argz_create (argv, &argz, &argz_len);
argz_stringify (argz, argz_len, ' ');
fs_debug (fs, "Spawned pid %d: %s", pid, argz);
if (flags & FSCK_F_VERBOSE)
puts (argz);
free (argz);
}
return pid;
}