*endp = '\0';
*nid = libcfs_str2nid(buf);
if (*nid == LNET_NID_ANY) {
- LCONSOLE_ERROR("Can't parse NID '%s'\n", buf);
+ LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", buf);
*endp = tmp;
return -EINVAL;
}
CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n",
MKSTR(typename), MKSTR(name), MKSTR(uuid));
- /* Mountconf transitional hack, should go away after 1.6.
- 1.4.7 uses the old names, so translate back if the
- mountconf flag is set.
- 1.6 should set this flag, and translate the other way here
- if not set. */
- if (lcfg->lcfg_flags & LCFG_FLG_MOUNTCONF){
- char *tmp = NULL;
- if (strcmp(typename, "mds") == 0)
- tmp = "mdt";
- if (strcmp(typename, "mdt") == 0)
- tmp = "mds";
- if (strcmp(typename, "osd") == 0)
- tmp = "obdfilter";
- if (tmp) {
- LCONSOLE_WARN("Using type %s for %s %s\n", tmp,
- MKSTR(typename), MKSTR(name));
- typename = tmp;
- }
- }
-
obd = class_newdev(typename, name);
if (IS_ERR(obd)) {
/* Already exists or out of obds */
cfs_init_timer(&obd->obd_recovery_timer);
spin_lock_init(&obd->obd_processing_task_lock);
cfs_waitq_init(&obd->obd_next_transno_waitq);
- CFS_INIT_LIST_HEAD(&obd->obd_recovery_queue);
- CFS_INIT_LIST_HEAD(&obd->obd_delayed_reply_queue);
+ cfs_waitq_init(&obd->obd_evict_inprogress_waitq);
+ CFS_INIT_LIST_HEAD(&obd->obd_req_replay_queue);
+ CFS_INIT_LIST_HEAD(&obd->obd_lock_replay_queue);
+ CFS_INIT_LIST_HEAD(&obd->obd_final_req_queue);
spin_lock_init(&obd->obd_uncommitted_replies_lock);
CFS_INIT_LIST_HEAD(&obd->obd_uncommitted_replies);
/* just leave this on forever. I can't use obd_set_up here because
other fns check that status, and we're not actually set up yet. */
obd->obd_starting = 1;
-
+ spin_unlock(&obd->obd_dev_lock);
+
/* create an uuid-export hash body */
err = lustre_hash_init(&obd->obd_uuid_hash_body, "UUID_HASH",
128, &uuid_hash_operations);
- if (err)
- GOTO(err_exp, err);
+ if (err) {
+ GOTO(err_hash, err);
+ }
/* create a nid-export hash body */
err = lustre_hash_init(&obd->obd_nid_hash_body, "NID_HASH",
128, &nid_hash_operations);
if (err)
- GOTO(err_exp, err);
-
- spin_unlock(&obd->obd_dev_lock);
+ GOTO(err_hash, err);
exp = class_new_export(obd, &obd->obd_uuid);
if (IS_ERR(exp))
list_del_init(&exp->exp_obd_chain_timed);
class_export_put(exp);
- err = obd_setup(obd, sizeof(*lcfg), lcfg);
+ err = obd_setup(obd, lcfg);
if (err)
GOTO(err_exp, err);
obd->obd_set_up = 1;
+
spin_lock(&obd->obd_dev_lock);
/* cleanup drops this */
class_incref(obd);
RETURN(0);
err_exp:
- CERROR("setup %s failed (%d)\n", obd->obd_name, err);
- lustre_hash_exit(&obd->obd_uuid_hash_body);
- lustre_hash_exit(&obd->obd_nid_hash_body);
class_unlink_export(obd->obd_self_export);
obd->obd_self_export = NULL;
+err_hash:
+ lustre_hash_exit(&obd->obd_uuid_hash_body);
+ lustre_hash_exit(&obd->obd_nid_hash_body);
obd->obd_starting = 0;
+ CERROR("setup %s failed (%d)\n", obd->obd_name, err);
RETURN(err);
}
obd->obd_force = 1;
break;
case 'A':
- LCONSOLE_WARN("Failing over %s\n",
+ LCONSOLE_WARN("Failing over %s\n",
obd->obd_name);
obd->obd_fail = 1;
obd->obd_no_transno = 1;
dump_exports(obd);
/* Allow a failed cleanup to try again. */
obd->obd_stopping = 0;
- RETURN(-EBUSY);
}
#endif
/* refcounf - 3 might be the number of real exports
dump_exports(obd);
class_disconnect_exports(obd);
}
-
LASSERT(obd->obd_self_export);
/* destroy an uuid-export hash body */
class_decref(obd);
obd->obd_set_up = 0;
-
RETURN(0);
}
if (err)
CERROR("Precleanup %s returned %d\n",
obd->obd_name, err);
+
+ spin_lock(&obd->obd_self_export->exp_lock);
obd->obd_self_export->exp_flags |=
(obd->obd_fail ? OBD_OPT_FAILOVER : 0) |
(obd->obd_force ? OBD_OPT_FORCE : 0);
+ spin_unlock(&obd->obd_self_export->exp_lock);
+
/* note that we'll recurse into class_decref again */
class_unlink_export(obd->obd_self_export);
return;
RETURN(-EINVAL);
}
if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) &&
- strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME) &&
+ strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME) &&
strcmp(obd->obd_type->typ_name, LUSTRE_MGC_NAME)) {
CERROR("can't add connection on non-client dev\n");
RETURN(-EINVAL);
RETURN(rc);
}
+int class_sec_flavor(struct obd_device *obd, struct lustre_cfg *lcfg)
+{
+ struct sec_flavor_config *conf;
+ ENTRY;
+
+ if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) &&
+ strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME)) {
+ CERROR("Can't set security flavor on obd %s\n",
+ obd->obd_type->typ_name);
+ RETURN(-EINVAL);
+ }
+
+ if (LUSTRE_CFG_BUFLEN(lcfg, 1) != sizeof(*conf)) {
+ CERROR("invalid data\n");
+ RETURN(-EINVAL);
+ }
+
+ conf = &obd->u.cli.cl_sec_conf;
+ memcpy(conf, lustre_cfg_buf(lcfg, 1), sizeof(*conf));
+
+#ifdef __BIG_ENDIAN
+ __swab32s(&conf->sfc_rpc_flavor);
+ __swab32s(&conf->sfc_bulk_csum);
+ __swab32s(&conf->sfc_bulk_priv);
+ __swab32s(&conf->sfc_flags);
+#endif
+
+ RETURN(0);
+}
+
CFS_LIST_HEAD(lustre_profile_list);
-struct lustre_profile *class_get_profile(char * prof)
+struct lustre_profile *class_get_profile(const char * prof)
{
struct lustre_profile *lprof;
memcpy(lprof->lp_profile, prof, proflen);
LASSERT(osclen == (strlen(osc) + 1));
- OBD_ALLOC(lprof->lp_osc, osclen);
- if (lprof->lp_osc == NULL)
+ OBD_ALLOC(lprof->lp_dt, osclen);
+ if (lprof->lp_dt == NULL)
GOTO(out, err = -ENOMEM);
- memcpy(lprof->lp_osc, osc, osclen);
+ memcpy(lprof->lp_dt, osc, osclen);
if (mdclen > 0) {
LASSERT(mdclen == (strlen(mdc) + 1));
- OBD_ALLOC(lprof->lp_mdc, mdclen);
- if (lprof->lp_mdc == NULL)
+ OBD_ALLOC(lprof->lp_md, mdclen);
+ if (lprof->lp_md == NULL)
GOTO(out, err = -ENOMEM);
- memcpy(lprof->lp_mdc, mdc, mdclen);
+ memcpy(lprof->lp_md, mdc, mdclen);
}
list_add(&lprof->lp_list, &lustre_profile_list);
RETURN(err);
out:
- if (lprof->lp_mdc)
- OBD_FREE(lprof->lp_mdc, mdclen);
- if (lprof->lp_osc)
- OBD_FREE(lprof->lp_osc, osclen);
+ if (lprof->lp_md)
+ OBD_FREE(lprof->lp_md, mdclen);
+ if (lprof->lp_dt)
+ OBD_FREE(lprof->lp_dt, osclen);
if (lprof->lp_profile)
OBD_FREE(lprof->lp_profile, proflen);
OBD_FREE(lprof, sizeof(*lprof));
RETURN(err);
}
-void class_del_profile(char *prof)
+void class_del_profile(const char *prof)
{
struct lustre_profile *lprof;
ENTRY;
if (lprof) {
list_del(&lprof->lp_list);
OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1);
- OBD_FREE(lprof->lp_osc, strlen(lprof->lp_osc) + 1);
- if (lprof->lp_mdc)
- OBD_FREE(lprof->lp_mdc, strlen(lprof->lp_mdc) + 1);
+ OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
+ if (lprof->lp_md)
+ OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
OBD_FREE(lprof, sizeof *lprof);
}
EXIT;
list_for_each_entry_safe(lprof, n, &lustre_profile_list, lp_list) {
list_del(&lprof->lp_list);
OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1);
- OBD_FREE(lprof->lp_osc, strlen(lprof->lp_osc) + 1);
- if (lprof->lp_mdc)
- OBD_FREE(lprof->lp_mdc, strlen(lprof->lp_mdc) + 1);
+ OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
+ if (lprof->lp_md)
+ OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
OBD_FREE(lprof, sizeof *lprof);
}
EXIT;
CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
obd_timeout, lcfg->lcfg_num);
obd_timeout = max(lcfg->lcfg_num, 1U);
+ obd_health_check_timeout = HEALTH_CHECK_TIMEOUT;
GOTO(out, err = 0);
}
case LCFG_SET_UPCALL: {
- LCONSOLE_ERROR("recovery upcall is deprecated\n");
+ LCONSOLE_ERROR_MSG(0x15a, "recovery upcall is deprecated\n");
/* COMPAT_146 Don't fail on old configs */
GOTO(out, err = 0);
}
struct cfg_marker *marker;
marker = lustre_cfg_buf(lcfg, 1);
CDEBUG(D_IOCTL, "marker %d (%#x) %.16s %s\n", marker->cm_step,
- marker->cm_flags, marker->cm_tgtname, marker->cm_comment);
+ marker->cm_flags, marker->cm_tgtname, marker->cm_comment);
GOTO(out, err = 0);
}
case LCFG_PARAM: {
err = class_del_conn(obd, lcfg);
GOTO(out, err = 0);
}
+ case LCFG_SEC_FLAVOR: {
+ err = class_sec_flavor(obd, lcfg);
+ GOTO(out, err = 0);
+ }
default: {
err = obd_process_config(obd, sizeof(*lcfg), lcfg);
GOTO(out, err);
#ifdef __KERNEL__
struct lprocfs_vars *var;
char *key, *sval;
- int i, vallen;
+ int i, keylen, vallen;
int matched = 0, j = 0;
int rc = 0;
ENTRY;
/* continue parsing other params */
continue;
}
+ keylen = sval - key;
sval++;
vallen = strlen(sval);
matched = 0;
/* Search proc entries */
while (lvars[j].name) {
var = &lvars[j];
- if (class_match_param(key, (char *)var->name, 0) == 0) {
+ if (class_match_param(key, (char *)var->name, 0) == 0 &&
+ keylen == strlen(var->name)) {
matched++;
rc = -EROFS;
if (var->write_fptr) {
}
if (!matched) {
CERROR("%s: unknown param %s\n",
- lustre_cfg_buf(lcfg, 0), key);
+ (char *)lustre_cfg_string(lcfg, 0), key);
rc = -EINVAL;
/* continue parsing other params */
} else {
LCONSOLE_INFO("%s.%.*s: set parameter %.*s=%s\n",
- lustre_cfg_buf(lcfg, 0),
- strlen(prefix) - 1, prefix,
- sval - key - 1, key, sval);
+ (char *)lustre_cfg_string(lcfg, 0),
+ (int)strlen(prefix) - 1, prefix,
+ (int)(sval - key - 1), key, sval);
}
}
char *cfg_buf = (char*) (rec + 1);
int rc = 0;
ENTRY;
-
+
//class_config_dump_handler(handle, rec, data);
switch (rec->lrh_type) {
if (!(clli->cfg_flags & CFG_F_COMPAT146) &&
!(clli->cfg_flags & CFG_F_MARKER) &&
(lcfg->lcfg_command != LCFG_MARKER)) {
- CWARN("Config not inside markers, ignoring! (%#x)\n",
- clli->cfg_flags);
+ CWARN("Config not inside markers, ignoring! "
+ "(inst: %s, uuid: %s, flags: %#x)\n",
+ clli->cfg_instance ? clli->cfg_instance : "<null>",
+ clli->cfg_uuid.uuid, clli->cfg_flags);
clli->cfg_flags |= CFG_F_SKIP;
}
-
if (clli->cfg_flags & CFG_F_SKIP) {
CDEBUG(D_CONFIG, "skipping %#x\n",
clli->cfg_flags);
lustre_cfg_string(lcfg, 0),
clli->cfg_instance);
lustre_cfg_bufs_set_string(&bufs, 0, inst_name);
- CDEBUG(D_CONFIG, "cmd %x, instance name: %s\n",
+ CDEBUG(D_CONFIG, "cmd %x, instance name: %s\n",
lcfg->lcfg_command, inst_name);
}
CDEBUG(D_CONFIG, "Processed log %s gen %d-%d (rc=%d)\n", name,
cd.first_idx + 1, cd.last_idx, rc);
+
if (cfg)
cfg->cfg_last_idx = cd.last_idx;
if (lcfg->lcfg_command == LCFG_MARKER) {
struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
ptr += snprintf(ptr, end-ptr, "marker=%d(%#x)%s '%s'",
- marker->cm_step, marker->cm_flags,
+ marker->cm_step, marker->cm_flags,
marker->cm_tgtname, marker->cm_comment);
} else {
for (i = 0; i < lcfg->lcfg_bufcount; i++) {
git://git.whamcloud.com / fs / lustre-release.git / blobdiff