int jt_lcfg_set_timeout(int argc, char **argv)
{
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
fprintf(stderr, "%s has been deprecated. Use conf_param instead.\n"
"e.g. conf_param lustre-MDT0000 obd_timeout=50\n",
jt_cmdname(argv[0]));
return CMD_HELP;
if (argc != 2)
return CMD_HELP;
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
lcfg = lustre_cfg_new(LCFG_SET_TIMEOUT, &bufs);
lcfg->lcfg_num = atoi(argv[1]);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
//rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc < 0) {
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
}
return rc;
}
static
int do_add_uuid(char * func, char *uuid, lnet_nid_t nid)
{
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
if (uuid)
lustre_cfg_bufs_set_string(&bufs, 1, uuid);
lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
lcfg->lcfg_nid = nid;
/* Poison NAL -- pre 1.4.6 will LASSERT on 0 NAL, this way it
doesn't work without crashing (bz 10130) */
lcfg->lcfg_nal = 0x5a;
#if 0
fprintf(stderr, "adding\tnid: %d\tuuid: %s\n",
lcfg->lcfg_nid, uuid);
#endif
rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc) {
fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
strerror(errno));
return -1;
}
printf ("Added uuid %s: %s\n", uuid, libcfs_nid2str(nid));
return 0;
}
int jt_lcfg_del_uuid(int argc, char **argv)
{
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
if (argc != 2) {
fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
return 0;
}
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
if (strcmp (argv[1], "_all_"))
lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc) {
fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
strerror(errno));
return -1;
}
return 0;
}
int jt_lcfg_setup(int argc, char **argv)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
int i;
int rc;
if (lcfg_devname == NULL) {
fprintf(stderr, "%s: please use 'device name' to set the "
"device name for config commands.\n",
jt_cmdname(argv[0]));
return -EINVAL;
}
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
if (argc > 6)
return CMD_HELP;
for (i = 1; i < argc; i++) {
lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
}
lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
return rc;
}
static
int do_add_uuid(char * func, char *uuid, lnet_nid_t nid)
{
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
if (uuid != NULL)
lustre_cfg_bufs_set_string(&bufs, 1, uuid);
lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
if (lcfg == NULL) {
rc = -ENOMEM;
} else {
lcfg->lcfg_nid = nid;
rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
}
if (rc) {
fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
strerror(errno));
return -1;
}
if (uuid != NULL)
printf("Added uuid %s: %s\n", uuid, libcfs_nid2str(nid));
return 0;
}
static int mgs_set_info_rpc(struct ptlrpc_request *req)
{
struct obd_device *obd = req->rq_export->exp_obd;
struct mgs_send_param *msp, *rep_msp;
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char fsname[MTI_NAME_MAXLEN];
ENTRY;
msp = req_capsule_client_get(&req->rq_pill, &RMF_MGS_SEND_PARAM);
LASSERT(msp);
/* Construct lustre_cfg structure to pass to function mgs_setparam */
lustre_cfg_bufs_reset(&bufs, NULL);
lustre_cfg_bufs_set_string(&bufs, 1, msp->mgs_param);
lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
rc = mgs_setparam(obd, lcfg, fsname);
if (rc) {
CERROR("Error %d in setting the parameter %s for fs %s\n",
rc, msp->mgs_param, fsname);
RETURN(rc);
}
lustre_cfg_free(lcfg);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc == 0) {
rep_msp = req_capsule_server_get(&req->rq_pill, &RMF_MGS_SEND_PARAM);
rep_msp = msp;
}
RETURN(rc);
}
int jt_lcfg_attach(int argc, char **argv)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
int rc;
if (argc != 4)
return CMD_HELP;
lustre_cfg_bufs_reset(&bufs, NULL);
lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
lustre_cfg_bufs_set_string(&bufs, 0, argv[2]);
lustre_cfg_bufs_set_string(&bufs, 2, argv[3]);
lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc < 0) {
fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
jt_cmdname(argv[0]), strerror(rc = errno));
} else {
lcfg_set_devname(argv[2]);
}
return rc;
}
/** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
* lctl (and do for echo cli/srv.
*/
int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
char *s1, char *s2, char *s3, char *s4)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg * lcfg = NULL;
int rc;
CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
cmd, s1, s2, s3, s4);
lustre_cfg_bufs_reset(&bufs, cfgname);
if (s1)
lustre_cfg_bufs_set_string(&bufs, 1, s1);
if (s2)
lustre_cfg_bufs_set_string(&bufs, 2, s2);
if (s3)
lustre_cfg_bufs_set_string(&bufs, 3, s3);
if (s4)
lustre_cfg_bufs_set_string(&bufs, 4, s4);
lcfg = lustre_cfg_new(cmd, &bufs);
lcfg->lcfg_nid = nid;
rc = class_process_config(lcfg);
lustre_cfg_free(lcfg);
return(rc);
}
/* Param set locally, directly on target */
int jt_lcfg_param(int argc, char **argv)
{
int i, rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
if (argc >= LUSTRE_CFG_MAX_BUFCOUNT)
return CMD_HELP;
lustre_cfg_bufs_reset(&bufs, NULL);
for (i = 1; i < argc; i++) {
lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
}
lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc < 0) {
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
}
return rc;
}
int jt_lcfg_del_mount_option(int argc, char **argv)
{
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
if (argc != 2)
return CMD_HELP;
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
/* profile name */
lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
if (lcfg == NULL) {
rc = -ENOMEM;
} else {
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
}
if (rc < 0) {
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
}
return rc;
}
int jt_lcfg_del_conn(int argc, char **argv)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
int rc;
if (argc != 2)
return CMD_HELP;
if (lcfg_devname == NULL) {
fprintf(stderr, "%s: please use 'device name' to set the "
"device name for config commands.\n",
jt_cmdname(argv[0]));
return -EINVAL;
}
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
/* connection uuid */
lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc < 0) {
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
}
return rc;
}
int jt_obd_detach(int argc, char **argv)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
int rc;
if (lcfg_devname == NULL) {
fprintf(stderr, "%s: please use 'device name' to set the "
"device name for config commands.\n",
jt_cmdname(argv[0]));
return -EINVAL;
}
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
if (argc != 1)
return CMD_HELP;
lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
return rc;
}
static int disconnect_echo_client(void)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg = NULL;
int err;
ENTRY;
/* cleanup echo_client */
lustre_cfg_bufs_reset(&bufs, echo_dev_name);
lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
err = class_process_config(lcfg);
if (err < 0) {
lustre_cfg_free(lcfg);
CERROR("failed cleanup echo_client\n");
RETURN(-EINVAL);
}
/* detach echo_client */
lcfg->lcfg_command = LCFG_DETACH;
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed detach echo_client\n");
RETURN(-EINVAL);
}
/* cleanup osc */
lustre_cfg_bufs_reset(&bufs, osc_dev_name);
lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
err = class_process_config(lcfg);
if (err < 0) {
lustre_cfg_free(lcfg);
CERROR("failed cleanup osc device\n");
RETURN(-EINVAL);
}
/* detach osc */
lcfg->lcfg_command = LCFG_DETACH;
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed detach osc device\n");
RETURN(-EINVAL);
}
RETURN(0);
}
/* After removal of a parameter (-d) Lustre will use the default
* AT NEXT REBOOT, not immediately. */
int jt_lcfg_mgsparam(int argc, char **argv)
{
int rc;
int del = 0;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char *buf = NULL;
#if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 7, 53, 0)
fprintf(stderr, "warning: 'lctl conf_param' is deprecated, "
"use 'lctl set_param -P' instead\n");
#endif
/* mgs_setparam processes only lctl buf #1 */
if ((argc > 3) || (argc <= 1))
return CMD_HELP;
while ((rc = getopt(argc, argv, "d")) != -1) {
switch (rc) {
case 'd':
del = 1;
break;
default:
return CMD_HELP;
}
}
lustre_cfg_bufs_reset(&bufs, NULL);
if (del) {
char *ptr;
/* for delete, make it "<param>=\0" */
buf = malloc(strlen(argv[optind]) + 2);
/* put an '=' on the end in case it doesn't have one */
sprintf(buf, "%s=", argv[optind]);
/* then truncate after the first '=' */
ptr = strchr(buf, '=');
*(++ptr) = '\0';
lustre_cfg_bufs_set_string(&bufs, 1, buf);
} else {
lustre_cfg_bufs_set_string(&bufs, 1, argv[optind]);
}
/* We could put other opcodes here. */
lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
if (buf)
free(buf);
if (rc < 0) {
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
}
return rc;
}
int jt_obd_cleanup(int argc, char **argv)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char force = 'F';
char failover = 'A';
char flags[3] = { 0 };
int flag_cnt = 0, n;
int rc;
if (lcfg_devname == NULL) {
fprintf(stderr, "%s: please use 'device name' to set the "
"device name for config commands.\n",
jt_cmdname(argv[0]));
return -EINVAL;
}
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
if (argc < 1 || argc > 3)
return CMD_HELP;
/* we are protected from overflowing our buffer by the argc
* check above
*/
for (n = 1; n < argc; n++) {
if (strcmp(argv[n], "force") == 0) {
flags[flag_cnt++] = force;
} else if (strcmp(argv[n], "failover") == 0) {
flags[flag_cnt++] = failover;
} else {
fprintf(stderr, "unknown option: %s\n", argv[n]);
return CMD_HELP;
}
}
if (flag_cnt) {
lustre_cfg_bufs_set_string(&bufs, 1, flags);
}
lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
if (lcfg == NULL) {
rc = -ENOMEM;
} else {
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
}
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
return rc;
}
/** Get a config log from the MGS and process it.
* This func is called for both clients and servers.
* Continue to process new statements appended to the logs
* (whenever the config lock is revoked) until lustre_end_log
* is called.
* @param sb The superblock is used by the MGC to write to the local copy of
* the config log
* @param logname The name of the llog to replicate from the MGS
* @param cfg Since the same mgc may be used to follow multiple config logs
* (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
* this log, and is added to the mgc's list of logs to follow.
*/
int lustre_process_log(struct super_block *sb, char *logname,
struct config_llog_instance *cfg)
{
struct lustre_cfg *lcfg;
struct lustre_cfg_bufs *bufs;
struct lustre_sb_info *lsi = s2lsi(sb);
struct obd_device *mgc = lsi->lsi_mgc;
int rc;
LASSERT(mgc);
LASSERT(cfg);
OBD_ALLOC_PTR(bufs);
if (bufs == NULL)
return -ENOMEM;
/* mgc_process_config */
lustre_cfg_bufs_reset(bufs, mgc->obd_name);
lustre_cfg_bufs_set_string(bufs, 1, logname);
lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
lcfg = lustre_cfg_new(LCFG_LOG_START, bufs);
rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
lustre_cfg_free(lcfg);
OBD_FREE_PTR(bufs);
if (rc == -EINVAL)
LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
"failed from the MGS (%d). Make sure this "
"client and the MGS are running compatible "
"versions of Lustre.\n",
mgc->obd_name, logname, rc);
if (rc)
LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
"failed (%d). This may be the result of "
"communication errors between this node and "
"the MGS, a bad configuration, or other "
"errors. See the syslog for more "
"information.\n", mgc->obd_name, logname,
rc);
/* class_obd_list(); */
return rc;
}
int jt_lcfg_add_conn(int argc, char **argv)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
int priority;
int rc;
if (argc == 2)
priority = 0;
else if (argc == 3)
priority = 1;
else
return CMD_HELP;
if (lcfg_devname == NULL) {
fprintf(stderr, "%s: please use 'device name' to set the "
"device name for config commands.\n",
jt_cmdname(argv[0]));
return -EINVAL;
}
lustre_cfg_bufs_reset(&bufs, lcfg_devname);
lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
if (lcfg == NULL) {
rc = -ENOMEM;
} else {
lcfg->lcfg_num = priority;
rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
lustre_cfg_free(lcfg);
}
if (rc < 0) {
fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
strerror(rc = errno));
}
return rc;
}
/* Stop watching this config log for updates */
int lustre_end_log(struct super_block *sb, char *logname,
struct config_llog_instance *cfg)
{
struct lustre_cfg *lcfg;
struct lustre_cfg_bufs bufs;
struct lustre_sb_info *lsi = s2lsi(sb);
struct obd_device *mgc = lsi->lsi_mgc;
int rc;
if (!mgc)
return -ENOENT;
/* mgc_process_config */
lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
lustre_cfg_bufs_set_string(&bufs, 1, logname);
if (cfg)
lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
lustre_cfg_free(lcfg);
return rc;
}
static int connect_echo_client(void)
{
struct lustre_cfg *lcfg;
struct lustre_cfg_bufs bufs;
lnet_nid_t nid;
char *peer = "ECHO_PEER_NID";
class_uuid_t osc_uuid, echo_uuid;
struct obd_uuid osc_uuid_str, echo_uuid_str;
int err;
ENTRY;
ll_generate_random_uuid(osc_uuid);
class_uuid_unparse(osc_uuid, &osc_uuid_str);
ll_generate_random_uuid(echo_uuid);
class_uuid_unparse(echo_uuid, &echo_uuid_str);
nid = libcfs_str2nid(echo_server_nid);
if (nid == LNET_NID_ANY) {
CERROR("Can't parse NID %s\n", echo_server_nid);
RETURN(-EINVAL);
}
/* add uuid */
lustre_cfg_bufs_reset(&bufs, NULL);
lustre_cfg_bufs_set_string(&bufs, 1, peer);
lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
lcfg->lcfg_nid = nid;
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed add_uuid\n");
RETURN(-EINVAL);
}
/* attach osc */
lustre_cfg_bufs_reset(&bufs, osc_dev_name);
lustre_cfg_bufs_set_string(&bufs, 1, LUSTRE_OSC_NAME);
lustre_cfg_bufs_set_string(&bufs, 2, osc_uuid_str.uuid);
lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed attach osc\n");
RETURN(-EINVAL);
}
/* setup osc */
lustre_cfg_bufs_reset(&bufs, osc_dev_name);
lustre_cfg_bufs_set_string(&bufs, 1, echo_server_ostname);
lustre_cfg_bufs_set_string(&bufs, 2, peer);
lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed setup osc\n");
RETURN(-EINVAL);
}
/* attach echo_client */
lustre_cfg_bufs_reset(&bufs, echo_dev_name);
lustre_cfg_bufs_set_string(&bufs, 1, "echo_client");
lustre_cfg_bufs_set_string(&bufs, 2, echo_uuid_str.uuid);
lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed attach echo_client\n");
RETURN(-EINVAL);
}
/* setup echo_client */
lustre_cfg_bufs_reset(&bufs, echo_dev_name);
lustre_cfg_bufs_set_string(&bufs, 1, osc_dev_name);
lustre_cfg_bufs_set_string(&bufs, 2, NULL);
lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err < 0) {
CERROR("failed setup echo_client\n");
RETURN(-EINVAL);
}
RETURN(0);
}
/* Param set to single log file, used by all clients and servers.
* This should be loaded after the individual config logs.
* Called from set param with -P option.
*/
static int jt_lcfg_mgsparam2(int argc, char **argv, struct param_opts *popt)
{
int rc, i;
int first_param;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char *buf = NULL;
int len;
first_param = optind;
if (first_param < 0 || first_param >= argc)
return CMD_HELP;
for (i = first_param, rc = 0; i < argc; i++) {
lustre_cfg_bufs_reset(&bufs, NULL);
/* This same command would be executed on all nodes, many
* of which should fail (silently) because they don't have
* that proc file existing locally. There would be no
* preprocessing on the MGS to try to figure out which
* parameter files to add this to, there would be nodes
* processing on the cluster nodes to try to figure out
* if they are the intended targets. They will blindly
* try to set the parameter, and ENOTFOUND means it wasn't
* for them.
* Target name "general" means call on all targets. It is
* left here in case some filtering will be added in
* future.
*/
lustre_cfg_bufs_set_string(&bufs, 0, "general");
len = strlen(argv[i]);
/* put an '=' on the end in case it doesn't have one */
if (popt->po_delete && argv[i][len - 1] != '=') {
buf = malloc(len + 1);
sprintf(buf, "%s=", argv[i]);
} else {
buf = argv[i];
}
lustre_cfg_bufs_set_string(&bufs, 1, buf);
lcfg = lustre_cfg_new(LCFG_SET_PARAM, &bufs);
if (IS_ERR(lcfg)) {
fprintf(stderr, "error: allocating lcfg for %s: %s\n",
jt_cmdname(argv[0]), strerror(PTR_ERR(lcfg)));
if (rc == 0)
rc = PTR_ERR(lcfg);
} else {
int rc2 = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
if (rc2 != 0) {
fprintf(stderr, "error: executing %s: %s\n",
jt_cmdname(argv[0]), strerror(errno));
if (rc == 0)
rc = rc2;
}
lustre_cfg_free(lcfg);
}
if (buf != argv[i])
free(buf);
}
return rc;
}
int liblustre_process_log(struct config_llog_instance *cfg,
char *mgsnid, char *profile,
int allow_recov)
{
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char *peer = "MGS_UUID";
struct obd_device *obd;
struct obd_export *exp;
char *name = "mgc_dev";
class_uuid_t uuid;
struct obd_uuid mgc_uuid;
struct llog_ctxt *ctxt;
lnet_nid_t nid = 0;
char *mdsnid;
int err, rc = 0;
struct obd_connect_data *ocd = NULL;
ENTRY;
ll_generate_random_uuid(uuid);
class_uuid_unparse(uuid, &mgc_uuid);
nid = libcfs_str2nid(mgsnid);
if (nid == LNET_NID_ANY) {
CERROR("Can't parse NID %s\n", mgsnid);
RETURN(-EINVAL);
}
lustre_cfg_bufs_reset(&bufs, NULL);
lustre_cfg_bufs_set_string(&bufs, 1, peer);
lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
lcfg->lcfg_nid = nid;
rc = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (rc < 0)
GOTO(out, rc);
lustre_cfg_bufs_reset(&bufs, name);
lustre_cfg_bufs_set_string(&bufs, 1, LUSTRE_MGC_NAME);
lustre_cfg_bufs_set_string(&bufs, 2, mgc_uuid.uuid);
lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
rc = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (rc < 0)
GOTO(out_del_uuid, rc);
lustre_cfg_bufs_reset(&bufs, name);
lustre_cfg_bufs_set_string(&bufs, 1, LUSTRE_MGS_OBDNAME);
lustre_cfg_bufs_set_string(&bufs, 2, peer);
lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
rc = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (rc < 0)
GOTO(out_detach, rc);
while ((mdsnid = strsep(&mgsnid, ","))) {
nid = libcfs_str2nid(mdsnid);
lustre_cfg_bufs_reset(&bufs, NULL);
lustre_cfg_bufs_set_string(&bufs, 1, libcfs_nid2str(nid));
lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
lcfg->lcfg_nid = nid;
rc = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (rc) {
CERROR("Add uuid for %s failed %d\n",
libcfs_nid2str(nid), rc);
continue;
}
lustre_cfg_bufs_reset(&bufs, name);
lustre_cfg_bufs_set_string(&bufs, 1, libcfs_nid2str(nid));
lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
lcfg->lcfg_nid = nid;
rc = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (rc) {
CERROR("Add conn for %s failed %d\n",
libcfs_nid2str(nid), rc);
continue;
}
}
obd = class_name2obd(name);
if (obd == NULL)
GOTO(out_cleanup, rc = -EINVAL);
OBD_ALLOC(ocd, sizeof(*ocd));
if (ocd == NULL)
GOTO(out_cleanup, rc = -ENOMEM);
ocd->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
OBD_CONNECT_FULL20;
ocd->ocd_version = LUSTRE_VERSION_CODE;
rc = obd_connect(NULL, &exp, obd, &mgc_uuid, ocd, NULL);
if (rc) {
CERROR("cannot connect to %s at %s: rc = %d\n",
LUSTRE_MGS_OBDNAME, mgsnid, rc);
GOTO(out_cleanup, rc);
}
ctxt = llog_get_context(exp->exp_obd, LLOG_CONFIG_REPL_CTXT);
cfg->cfg_flags |= CFG_F_COMPAT146;
rc = class_config_parse_llog(NULL, ctxt, profile, cfg);
llog_ctxt_put(ctxt);
if (rc) {
CERROR("class_config_parse_llog failed: rc = %d\n", rc);
}
/* We don't so much care about errors in cleaning up the config llog
* connection, as we have already read the config by this point. */
err = obd_disconnect(exp);
if (err)
CERROR("obd_disconnect failed: rc = %d\n", err);
out_cleanup:
if (ocd)
OBD_FREE(ocd, sizeof(*ocd));
lustre_cfg_bufs_reset(&bufs, name);
lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err)
CERROR("md_cleanup failed: rc = %d\n", err);
out_detach:
lustre_cfg_bufs_reset(&bufs, name);
lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
err = class_process_config(lcfg);
lustre_cfg_free(lcfg);
if (err)
CERROR("md_detach failed: rc = %d\n", err);
out_del_uuid:
lustre_cfg_bufs_reset(&bufs, name);
lustre_cfg_bufs_set_string(&bufs, 1, peer);
lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
err = class_process_config(lcfg);
if (err)
CERROR("del MDC UUID failed: rc = %d\n", err);
lustre_cfg_free(lcfg);
out:
RETURN(rc);
}
