static void *module_thread (void *arg)
{
module_t *p = arg;
assert (p->magic == MODULE_MAGIC);
sigset_t signal_set;
int errnum;
char *uri = xasprintf ("shmem://%s", zuuid_str (p->uuid));
char **av = NULL;
char *rankstr = NULL;
int ac;
assert (p->zctx);
/* Connect to broker socket, enable logging, register built-in services
*/
if (!(p->h = flux_open (uri, 0)))
err_exit ("flux_open %s", uri);
if (flux_opt_set (p->h, FLUX_OPT_ZEROMQ_CONTEXT,
p->zctx, sizeof (p->zctx)) < 0)
err_exit ("flux_opt_set ZEROMQ_CONTEXT");
rankstr = xasprintf ("%u", p->rank);
if (flux_attr_fake (p->h, "rank", rankstr, FLUX_ATTRFLAG_IMMUTABLE) < 0) {
err ("%s: error faking rank attribute", p->name);
goto done;
}
flux_log_set_facility (p->h, p->name);
modservice_register (p->h, p);
/* Block all signals
*/
if (sigfillset (&signal_set) < 0)
err_exit ("%s: sigfillset", p->name);
if ((errnum = pthread_sigmask (SIG_BLOCK, &signal_set, NULL)) != 0)
errn_exit (errnum, "pthread_sigmask");
/* Run the module's main().
*/
ac = argz_count (p->argz, p->argz_len);
av = xzmalloc (sizeof (av[0]) * (ac + 1));
argz_extract (p->argz, p->argz_len, av);
if (p->main(p->h, ac, av) < 0) {
err ("%s: mod_main returned error", p->name);
goto done;
}
done:
if (rankstr)
free (rankstr);
if (av)
free (av);
flux_close (p->h);
p->h = NULL;
return NULL;
}
static module_t *module_create (const char *path, char *argz, size_t argz_len)
{
module_t *m = xzmalloc (sizeof (*m));
struct stat sb;
char **av = NULL;
if (stat (path, &sb) < 0 || !(m->name = flux_modname (path, NULL, NULL))
|| !(m->digest = digest (path))) {
module_destroy (m);
errno = ESRCH;
return NULL;
}
m->size = sb.st_size;
m->dso = dlopen (path, RTLD_NOW | RTLD_LOCAL);
if (!m->dso || !(m->main = dlsym (m->dso, "mod_main"))) {
module_destroy (m);
errno = EINVAL;
return NULL;
}
av = xzmalloc (sizeof (av[0]) * (argz_count (argz, argz_len) + 1));
argz_extract (argz, argz_len, av);
if (m->main (NULL, argz_count (argz, argz_len), av) < 0) {
module_destroy (m);
errno = EINVAL;
return NULL;
}
if (zhash_lookup (modules, m->name)) {
module_destroy (m);
errno = EEXIST;
return NULL;
}
zhash_update (modules, m->name, m);
zhash_freefn (modules, m->name, (zhash_free_fn *)module_destroy);
if (av)
free (av);
return m;
}
/* Copyright (C) 2002 by Red Hat, Incorporated. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software
* is freely granted, provided that this notice is preserved.
*/
#include <argz.h>
#include <sys/types.h>
void
_DEFUN (argz_extract, (argz, argz_len, argv),
char *argz _AND
size_t argz_len _AND
char **argv)
{
size_t i = 0;
int j = 0;
const size_t count = argz_count(argz, argz_len);
for (i = argz_len - 2; i > 0; i--)
{
if (argz[i] == '\0')
{
j++;
argv[count - j] = &argz[i + 1];
}
}
argv[0] = &argz[0];
argv[count] = NULL;
}
int argz_execp (char *argz, size_t argz_len)
{
char *argv [argz_count (argz, argz_len) + 1];
argz_extract (argz, argz_len, argv);
return execvp (argv[0], argv);
}
int subprocess_get_argc (struct subprocess *p)
{
return (argz_count (p->argz, p->argz_len));
}
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
struct fstab_argp_params *params = state->input;
error_t err;
switch (key)
{
case ARGP_KEY_INIT:
state->child_inputs[0] = params; /* pass down to fstab_argp parser */
break;
#define ARGZ(call) \
err = argz_##call; \
if (err) \
argp_failure (state, 100, ENOMEM, "%s", arg); \
break
case 'r':
ARGZ (add (&options, &options_len, "ro"));
case 'w':
ARGZ (add (&options, &options_len, "rw"));
case 'u':
ARGZ (add (&options, &options_len, "update"));
case 'B':
ARGZ (add (&options, &options_len, "bind"));
case 'o':
ARGZ (add_sep (&options, &options_len, arg, ','));
case 'v':
++verbose;
break;
#undef ARGZ
case 'T':
{
char *end;
unsigned long int ms = strtoul (arg, &end, 10);
if (end && *end == '\0')
timeout = ms;
else
{
argp_error (state,
"--timeout needs a numeric argument (milliseconds)");
return EINVAL;
}
}
break;
case 'p':
if (arg == 0 || !strcasecmp (arg, "fstab"))
query_format = qf_fstab;
else if (!strcasecmp (arg, "mount"))
query_format = qf_standard;
else if (!strcasecmp (arg, "translator")
|| !strcasecmp (arg, "showtrans"))
query_format = qf_translator;
else
{
argp_error (state, "invalid argument to --format");
return EINVAL;
}
break;
case 'n':
/* do nothing */
break;
case 'f':
fake = 1;
break;
case 'O':
err = argz_create_sep (arg, ',', &test_opts, &test_opts_len);
if (err)
argp_failure (state, 100, ENOMEM, "%s", arg);
break;
case ARGP_KEY_ARG:
if (mountpoint == 0) /* One arg: mountpoint */
mountpoint = arg;
else if (device == 0) /* Two args: device, mountpoint */
{
device = mountpoint;
mountpoint = arg;
}
else /* More than two args. */
{
argp_error (state, "too many arguments");
return EINVAL;
}
break;
case ARGP_KEY_NO_ARGS:
if (! params->do_all)
{
params->do_all = 1;
mode = query;
}
break;
case ARGP_KEY_END:
if (params->do_all && mountpoint)
{
argp_error (state, "filesystem argument not allowed with --all");
return EINVAL;
}
if (mode == query && options_len != 0)
{
argp_error (state,
"mount options not allowed without filesystem argument");
return EINVAL;
}
if (mountpoint)
switch (argz_count (params->types, params->types_len))
{
default:
argp_error (state,
"multiple types not allowed with filesystem argument");
return EINVAL;
case 1:
fstype = params->types;
params->types = 0;
params->types_len = 0;
break;
case 0:
break;
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
