static void lstopo_argz_init (char *cmd, char **argzp, size_t *argz_lenp,
char *extra_args[])
{
char *extra;
size_t extra_len;
int e;
char *argv[] = { cmd, "-i", "-", "--if", "xml",
"--of", "console", NULL };
if ( (e = argz_create (argv, argzp, argz_lenp)) != 0
|| (e = argz_create (extra_args, &extra, &extra_len)) != 0)
log_msg_exit ("argz_create: %s", strerror (e));
/* Append any extra args in av[] */
if ((e = argz_append (argzp, argz_lenp, extra, extra_len)) != 0)
log_msg_exit ("argz_append: %s", strerror (e));
free (extra);
}
void module_set_args (module_t *p, int argc, char * const argv[])
{
assert (p->magic == MODULE_MAGIC);
if (p->argz) {
free (p->argz);
p->argz_len = 0;
}
if (argv && argz_create (argv, &p->argz, &p->argz_len) < 0)
oom ();
}
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;
}
static int init_argz (char **argzp, size_t *argz_lenp, char * const av[])
{
int e;
if (*argzp != NULL) {
free (*argzp);
*argz_lenp = 0;
}
if (av && (e = argz_create (av, argzp, argz_lenp)) != 0) {
errno = e;
return -1;
}
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;
}
error_t parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case OPT_USER_PAT: mux.user_pat = arg; break;
case OPT_HOME_PAT: mux.home_pat = arg; break;
case OPT_UID_PAT: mux.uid_pat = arg; break;
case 'C': memset (&mux, 0, sizeof mux); break;
case ARGP_KEY_NO_ARGS:
memset (&mux, 0, sizeof mux); /* Default doesn't use them;
be careful. */
return argz_create_sep (_HURD_SYMLINK, 0,
&mux.trans_template, &mux.trans_template_len);
case ARGP_KEY_ARGS:
/* Steal the entire tail of arg vector for our own use. */
return argz_create (state->argv + state->next,
&mux.trans_template, &mux.trans_template_len);
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
int
main(int argc, char *argv[])
{
error_t err;
/* The filesystem node we're putting a translator on. */
char *node_name = 0;
file_t node;
/* The translator's arg vector, in '\0' separated format. */
char *argz = 0;
size_t argz_len = 0;
/* The control port for any active translator we start up. */
fsys_t active_control = MACH_PORT_NULL;
/* Flags to pass to file_set_translator. */
int active_flags = 0;
int passive_flags = 0;
int lookup_flags = O_NOTRANS;
int goaway_flags = 0;
/* Various option flags. */
int passive = 0, active = 0, keep_active = 0, pause = 0, kill_active = 0,
orphan = 0;
int start = 0;
int stack = 0;
char *pid_file = NULL;
int excl = 0;
int timeout = DEFAULT_TIMEOUT * 1000; /* ms */
char *underlying_node_name = NULL;
int underlying_lookup_flags;
char **chroot_command = 0;
char *chroot_chdir = "/";
/* Parse our options... */
error_t parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case ARGP_KEY_ARG:
if (state->arg_num == 0)
node_name = arg;
else /* command */
{
if (start)
argp_error (state, "both --start and TRANSLATOR given");
error_t err =
argz_create (state->argv + state->next - 1, &argz, &argz_len);
if (err)
error(3, err, "Can't create options vector");
state->next = state->argc; /* stop parsing */
}
break;
case ARGP_KEY_NO_ARGS:
argp_usage (state);
return EINVAL;
case 'a': active = 1; break;
case 's':
start = 1;
active = 1; /* start implies active */
break;
case OPT_STACK:
stack = 1;
active = 1; /* stack implies active */
orphan = 1; /* stack implies orphan */
break;
case 'p': passive = 1; break;
case 'k': keep_active = 1; break;
case 'g': kill_active = 1; break;
case 'x': excl = 1; break;
case 'P': pause = 1; break;
case 'F':
pid_file = strdup (arg);
if (pid_file == NULL)
error(3, ENOMEM, "Failed to duplicate argument");
break;
case 'o': orphan = 1; break;
case 'U':
underlying_node_name = strdup (arg);
if (underlying_node_name == NULL)
error(3, ENOMEM, "Failed to duplicate argument");
break;
case 'C':
if (chroot_command)
{
argp_error (state, "--chroot given twice");
return EINVAL;
}
chroot_command = &state->argv[state->next];
while (state->next < state->argc)
{
if (!strcmp (state->argv[state->next], "--"))
{
state->argv[state->next++] = 0;
if (chroot_command[0] == 0)
{
argp_error (state,
"--chroot must be followed by a command");
return EINVAL;
}
return 0;
}
++state->next;
}
argp_error (state, "--chroot command must be terminated with `--'");
return EINVAL;
case OPT_CHROOT_CHDIR:
if (arg[0] != '/')
argp_error (state, "--chroot-chdir must be absolute");
chroot_chdir = arg;
break;
case 'c': lookup_flags |= O_CREAT; break;
case 'L': lookup_flags &= ~O_NOTRANS; break;
case 'R': goaway_flags |= FSYS_GOAWAY_RECURSE; break;
case 'S': goaway_flags |= FSYS_GOAWAY_NOSYNC; break;
case 'f': goaway_flags |= FSYS_GOAWAY_FORCE; break;
/* Use atof so the user can specifiy fractional timeouts. */
case 't': timeout = atof (arg) * 1000.0; break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
struct argp argp = {options, parse_opt, args_doc, doc};
argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, 0);
if (stack)
{
underlying_node_name = node_name;
underlying_lookup_flags = lookup_flags && ~O_NOTRANS;
}
else
underlying_lookup_flags = lookup_flags;
if (!active && !passive && !chroot_command)
passive = 1; /* By default, set the passive translator. */
if (passive)
passive_flags = FS_TRANS_SET | (excl ? FS_TRANS_EXCL : 0);
if (active)
active_flags = FS_TRANS_SET | (excl ? FS_TRANS_EXCL : 0)
| (orphan ? FS_TRANS_ORPHAN : 0);
if (passive && !active)
{
/* When setting just the passive, decide what to do with any active. */
if (kill_active)
/* Make it go away. */
active_flags = FS_TRANS_SET;
else if (! keep_active)
/* Ensure that there isn't one. */
active_flags = FS_TRANS_SET | FS_TRANS_EXCL;
}
if (start)
{
/* Retrieve the passive translator record in argz. */
mach_port_t node = file_name_lookup (node_name, lookup_flags, 0);
if (node == MACH_PORT_NULL)
error (4, errno, "%s", node_name);
char buf[1024];
argz = buf;
argz_len = sizeof (buf);
err = file_get_translator (node, &argz, &argz_len);
if (err == EINVAL)
error (4, 0, "%s: no passive translator record found", node_name);
if (err)
error (4, err, "%s", node_name);
mach_port_deallocate (mach_task_self (), node);
}
if ((active || chroot_command) && argz_len > 0)
{
/* Error during file lookup; we use this to avoid duplicating error
messages. */
error_t open_err = 0;
/* The callback to start_translator opens NODE as a side effect. */
error_t open_node (int flags,
mach_port_t *underlying,
mach_msg_type_name_t *underlying_type,
task_t task, void *cookie)
{
if (pause)
{
fprintf (stderr, "Translator pid: %d\nPausing...",
task2pid (task));
getchar ();
}
if (pid_file != NULL)
{
FILE *h;
h = fopen (pid_file, "w");
if (h == NULL)
error (4, errno, "Failed to open pid file");
fprintf (h, "%i\n", task2pid (task));
fclose (h);
}
node = file_name_lookup (node_name, flags | lookup_flags, 0666);
if (node == MACH_PORT_NULL)
{
open_err = errno;
return open_err;
}
if (underlying_node_name)
{
*underlying = file_name_lookup (underlying_node_name,
flags | underlying_lookup_flags,
0666);
if (! MACH_PORT_VALID (*underlying))
{
/* For the error message. */
node_name = underlying_node_name;
open_err = errno;
return open_err;
}
}
else
*underlying = node;
*underlying_type = MACH_MSG_TYPE_COPY_SEND;
return 0;
}
err = fshelp_start_translator (open_node, NULL, argz, argz, argz_len,
timeout, &active_control);
if (err)
/* If ERR is due to a problem opening the translated node, we print
that name, otherwise, the name of the translator. */
error(4, err, "%s", (err == open_err) ? node_name : argz);
}
void
main (int argc, char *argv[])
{
/* The filesystem node we're putting a translator on. */
char *node_name = 0;
/* The translator's arg vector, in '\0' separated format. */
/* The control port for any active translator we start up. */
/* Flags to pass to file_set_translator. */
int lookup_flags = 0;
int goaway_flags = 0;
/* Various option flags. */
int passive = 0, active = 0, keep_active = 0, pause = 0, kill_active = 0;
int excl = 0;
int timeout = DEFAULT_TIMEOUT * 1000; /* ms */
/* Parse our options... */
error_t parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case ARGP_KEY_ARG:
if (state->arg_num == 0)
node_name = arg;
else /* command */
{
abort ();
#if 0
error_t err =
argz_create (state->argv + state->next - 1, &argz, &argz_len);
if (err)
error(3, err, "Can't create options vector");
state->next = state->argc; /* stop parsing */
#endif
}
break;
case ARGP_KEY_NO_ARGS:
argp_usage (state);
return EINVAL;
case 'a': active = 1; break;
case 'p': passive = 1; break;
case 'k': keep_active = 1; break;
case 'g': kill_active = 1; break;
case 'x': excl = 1; break;
case 'P': pause = 1; break;
case 'c': lookup_flags |= 0; break;
case 'L': lookup_flags &= ~0; break;
case 'R': goaway_flags |= 0; break;
case 'S': goaway_flags |= 0; break;
case 'f': goaway_flags |= 0; break;
/* Use atof so the user can specifiy fractional timeouts. */
case 't': timeout = 1000.0; break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
struct argp argp = {options, parse_opt, args_doc, doc};
argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, 0);
exit (0);
}
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;
}
/* 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;
}
