param_t copy_params(param_t other){
param_t iter = other;
param_t r = NULL;
while(iter){
r = append_param(r, iter->key, iter->value);
iter = iter->next;
}
return r;
}
config_t get_state(const plc_t plc,
const config_t state){
config_t r = state;
int i = 0;
//set status
r = set_numeric_entry(0, plc->status, r);
//assign values
if(plc->update & CHANGED_I){
r = get_dio_values(plc, r, CONFIG_DI);
//analog
r = get_aio_values(plc, r, CONFIG_AI);
}
if(plc->update & CHANGED_O){
r = get_dio_values(plc, r, CONFIG_DQ);
//analog
r = get_aio_values(plc, r, CONFIG_AQ);
}
if(plc->update & CHANGED_M){
//registers
r = get_reg_values(plc, r);
//reals
r = get_aio_values(plc, r, CONFIG_MVAR);
}
if(plc->update & CHANGED_T){
//timers
r = get_timer_values(plc, r);
}
if(plc->update & CHANGED_S){
//pulses
r = get_pulse_values(plc, r);
}
//show forced
//add program
if( plc->update & CHANGED_STATUS) {
sequence_t programs = get_sequence_entry(CONFIG_PROGRAM, r);
for(i = 0;i < plc->rungno; i++){
codeline_t liter = plc->rungs[i]->code;
int lineno = 0;
char label[SMALLBUF] = "";
while(liter){
sprintf(label, "LINE %d", ++lineno);
param_t code = get_param(label,programs->vars[i].params);
if(code == NULL){
programs->vars[i].params = append_param(
programs->vars[i].params,
label,
liter->line);
}
liter = liter->next;
}
}
}
return r;
}
param_t update_param(const param_t params,
const char * key,
const char * val){
if(params == NULL){
return new_param(key, val);
} else {
param_t ret = params;
param_t par = get_param(key, params);
if(par){
par->value = strdup_r(par->value, val);
} else {
//FIXME: ..and this is why we need a hashmap.
ret = append_param(ret, key, val);
}
return ret;
}
}
_RetType operator()(PARAM param = tp::_null_tpl)
{
APPEND_PARAM append_param;
NEXT_PROC proc;
return proc(param + append_param());
}
int parse_opts(int argc, char *const argv[], struct mkfs_opts *mop,
char **mountopts)
{
static struct option long_opt[] = {
{ "backfs-mount-opts", required_argument, NULL, 'B' },
{ "failnode", required_argument, NULL, 'f' },
{ "failover", required_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "index", required_argument, NULL, 'i' },
{ "fsname", required_argument, NULL, 'L' },
{ "mgsnode", required_argument, NULL, 'm' },
{ "mgsnid", required_argument, NULL, 'm' },
{ "dryrun", no_argument, NULL, 'n' },
{ "mountfsoptions", required_argument, NULL, 'o' },
{ "param", required_argument, NULL, 'p' },
{ "quiet", no_argument, NULL, 'q' },
{ "servicenode", required_argument, NULL, 's' },
{ "network", required_argument, NULL, 't' },
{ "comment", required_argument, NULL, 'u' },
{ "force-nohostid", no_argument, NULL, 'U' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
#ifndef TUNEFS
{ "backfstype", required_argument, NULL, 'b' },
{ "stripe-count-hint", required_argument, NULL, 'c' },
{ "device-size", required_argument, NULL, 'd' },
{ "mgs", no_argument, NULL, 'G' },
{ "mkfsoptions", required_argument, NULL, 'k' },
{ "mdt", no_argument, NULL, 'M' },
{ "nomgs", no_argument, NULL, 'N' },
{ "ost", no_argument, NULL, 'O' },
{ "reformat", no_argument, NULL, 'r' },
{ "replace", no_argument, NULL, 'R' },
#else
{ "erase-params", no_argument, NULL, 'e' },
{ "quota", no_argument, NULL, 'Q' },
{ "writeconf", no_argument, NULL, 'w' },
#endif
{ 0, 0, NULL, 0 }
};
char *optstring = "B:f:hi:L:m:no:p:qs:t:u:vV"
#ifndef TUNEFS
"b:c:d:Gk:MNOrR";
#else
"eQw";
#endif
struct lustre_disk_data *ldd = &mop->mo_ldd;
char new_fsname[16] = { 0 };
int opt;
int rc, longidx;
int failnode_set = 0, servicenode_set = 0;
int replace = 0;
bool index_option = false;
while ((opt = getopt_long(argc, argv, optstring, long_opt, &longidx)) !=
EOF) {
switch (opt) {
case 'B':
mop->mo_mountopts = optarg;
break;
case 'f':
case 's': {
char *nids;
if ((opt == 'f' && servicenode_set) ||
(opt == 's' && failnode_set)) {
fprintf(stderr, "%s: %s cannot use with --%s\n",
progname, long_opt[longidx].name,
opt == 'f' ? "servicenode" :
"failnode");
return 1;
}
nids = convert_hostnames(optarg);
if (nids == NULL)
return 1;
rc = append_param(ldd->ldd_params, PARAM_FAILNODE,
nids, ':');
free(nids);
if (rc != 0)
return rc;
/* Must update the mgs logs */
ldd->ldd_flags |= LDD_F_UPDATE;
if (opt == 'f') {
failnode_set = 1;
} else {
ldd->ldd_flags |= LDD_F_NO_PRIMNODE;
servicenode_set = 1;
}
mop->mo_flags |= MO_FAILOVER;
break;
}
case 'h':
usage(stdout);
return 1;
case 'i': {
char *endptr = NULL;
int base;
index_option = true;
/* LU-2374: check whether it is OST/MDT later */
base = (strlen(optarg) > 1 &&
!strncmp(optarg, "0x", 2)) ? 16 : 10;
/* Allowed input are base 16 and base 10 numbers only */
mop->mo_ldd.ldd_svindex = strtoul(optarg,
&endptr, base);
if (*endptr != '\0') {
fprintf(stderr, "%s: wrong index %s. "
"Target index must be decimal or "
"hexadecimal.\n",
progname, optarg);
return 1;
}
if (ldd->ldd_svindex >= INDEX_UNASSIGNED) {
fprintf(stderr, "%s: wrong index %u. "
"Target index must be less than %u.\n",
progname, ldd->ldd_svindex,
INDEX_UNASSIGNED);
return 1;
}
ldd->ldd_flags &= ~LDD_F_NEED_INDEX;
break;
}
case 'L': {
rc = lustre_is_fsname_valid(optarg, 1,
LUSTRE_MAXFSNAME);
if (rc < 0) {
fprintf(stderr, "%s: filesystem name must be "
"1-%d chars\n", progname,
LUSTRE_MAXFSNAME);
return 1;
} else if (rc > 0) {
fprintf(stderr, "%s: char '%c' not allowed in "
"filesystem name\n", progname, rc);
return 1;
}
strscpy(new_fsname, optarg, sizeof(new_fsname));
break;
}
case 'm': {
char *nids = convert_hostnames(optarg);
if (nids == NULL)
return 1;
rc = append_param(ldd->ldd_params, PARAM_MGSNODE,
nids, ':');
free(nids);
if (rc != 0)
return rc;
mop->mo_mgs_failnodes++;
break;
}
case 'n':
print_only++;
break;
case 'o':
*mountopts = optarg;
break;
case 'p':
rc = add_param(ldd->ldd_params, NULL, optarg);
if (rc != 0)
return rc;
/* Must update the mgs logs */
ldd->ldd_flags |= LDD_F_UPDATE;
break;
case 'q':
verbose--;
break;
case 't':
if (!IS_MDT(ldd) && !IS_OST(ldd)) {
badopt(long_opt[longidx].name, "MDT,OST");
return 1;
}
if (optarg == NULL)
return 1;
rc = add_param(ldd->ldd_params, PARAM_NETWORK, optarg);
if (rc != 0)
return rc;
/* Must update the mgs logs */
ldd->ldd_flags |= LDD_F_UPDATE;
break;
case 'u':
strscpy(ldd->ldd_userdata, optarg,
sizeof(ldd->ldd_userdata));
break;
case 'U':
mop->mo_flags |= MO_NOHOSTID_CHECK;
break;
case 'v':
verbose++;
break;
case 'V':
++version;
fprintf(stdout, "%s %s\n", progname,
LUSTRE_VERSION_STRING);
return 0;
#ifndef TUNEFS
case 'b': {
int i = 0;
do {
if (strcmp(optarg, mt_str(i)) == 0) {
ldd->ldd_mount_type = i;
break;
}
} while (++i < LDD_MT_LAST);
if (i == LDD_MT_LAST) {
fprintf(stderr, "%s: invalid backend filesystem"
" type %s\n", progname, optarg);
return 1;
}
break;
}
case 'c':
if (IS_MDT(ldd)) {
int stripe_count = atol(optarg);
if (stripe_count <= 0) {
fprintf(stderr, "%s: bad stripe count "
"%d\n", progname, stripe_count);
return 1;
}
mop->mo_stripe_count = stripe_count;
} else {
badopt(long_opt[longidx].name, "MDT");
return 1;
}
break;
case 'd':
mop->mo_device_kb = atol(optarg);
break;
case 'G':
ldd->ldd_flags |= LDD_F_SV_TYPE_MGS;
break;
case 'k':
strscpy(mop->mo_mkfsopts, optarg,
sizeof(mop->mo_mkfsopts));
break;
case 'M':
ldd->ldd_flags |= LDD_F_SV_TYPE_MDT;
break;
case 'N':
ldd->ldd_flags &= ~LDD_F_SV_TYPE_MGS;
break;
case 'O':
ldd->ldd_flags |= LDD_F_SV_TYPE_OST;
break;
case 'r':
mop->mo_flags |= MO_FORCEFORMAT;
break;
case 'R':
replace = 1;
break;
#else /* !TUNEFS */
case 'e':
ldd->ldd_params[0] = '\0';
/* Must update the mgs logs */
ldd->ldd_flags |= LDD_F_UPDATE;
break;
case 'Q':
mop->mo_flags |= MO_QUOTA;
break;
case 'w':
ldd->ldd_flags |= LDD_F_WRITECONF;
break;
#endif /* !TUNEFS */
default:
if (opt != '?') {
fatal();
fprintf(stderr, "Unknown option '%c'\n", opt);
}
return EINVAL;
}
}
if (strlen(new_fsname) > 0) {
if (!(mop->mo_flags & MO_FORCEFORMAT) &&
(!(ldd->ldd_flags &
(LDD_F_UPGRADE14 | LDD_F_VIRGIN | LDD_F_WRITECONF)))) {
fprintf(stderr, "%s: cannot change the name "
"of a registered target\n", progname);
return 1;
}
strscpy(ldd->ldd_fsname, new_fsname, sizeof(ldd->ldd_fsname));
}
if (index_option && !(mop->mo_ldd.ldd_flags &
(LDD_F_UPGRADE14 | LDD_F_VIRGIN |
LDD_F_WRITECONF))) {
fprintf(stderr, "%s: cannot change the index of"
" a registered target\n", progname);
return 1;
}
/* Need to clear this flag after parsing 'L' and 'i' options. */
if (replace)
ldd->ldd_flags &= ~LDD_F_VIRGIN;
if (optind == argc) {
/* The user didn't specify device name */
fatal();
fprintf(stderr, "Not enough arguments - device name or "
"pool/dataset name not specified.\n");
return EINVAL;
} else {
/* The device or pool/filesystem name */
strscpy(mop->mo_device, argv[optind], sizeof(mop->mo_device));
/* Followed by optional vdevs */
if (optind < argc - 1)
mop->mo_pool_vdevs = (char **) &argv[optind + 1];
}
return 0;
}
