* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define D_MGS D_CONFIG
#include <obd.h>
-#include <obd_lov.h>
+#include <lustre_ioctl.h>
#include <lustre_param.h>
#include <lustre_sec.h>
#include <lustre_quota.h>
/********************** Class functions ********************/
+/* Find all logs in CONFIG directory and link then into list */
int class_dentry_readdir(const struct lu_env *env,
- struct mgs_device *mgs, cfs_list_t *list)
+ struct mgs_device *mgs, struct list_head *log_list)
{
struct dt_object *dir = mgs->mgs_configs_dir;
const struct dt_it_ops *iops;
char *key;
int rc, key_sz;
- CFS_INIT_LIST_HEAD(list);
-
- if (!dt_try_as_dir(env, dir))
- GOTO(out, rc = -ENOTDIR);
+ INIT_LIST_HEAD(log_list);
LASSERT(dir);
LASSERT(dir->do_index_ops);
break;
}
- memcpy(de->name, key, key_sz);
- de->name[key_sz] = 0;
+ memcpy(de->mde_name, key, key_sz);
+ de->mde_name[key_sz] = 0;
- cfs_list_add(&de->list, list);
+ list_add(&de->mde_list, log_list);
next:
rc = iops->next(env, it);
fini:
iops->fini(env, it);
-out:
if (rc)
CERROR("%s: key failed when listing %s: rc = %d\n",
mgs->mgs_obd->obd_name, MOUNT_CONFIGS_DIR, rc);
struct fs_db *mgs_find_fsdb(struct mgs_device *mgs, char *fsname)
{
struct fs_db *fsdb;
- cfs_list_t *tmp;
+ struct list_head *tmp;
- cfs_list_for_each(tmp, &mgs->mgs_fs_db_list) {
- fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
+ list_for_each(tmp, &mgs->mgs_fs_db_list) {
+ fsdb = list_entry(tmp, struct fs_db, fsdb_list);
if (strcmp(fsdb->fsdb_name, fsname) == 0)
return fsdb;
}
lproc_mgs_add_live(mgs, fsdb);
}
- cfs_list_add(&fsdb->fsdb_list, &mgs->mgs_fs_db_list);
+ list_add(&fsdb->fsdb_list, &mgs->mgs_fs_db_list);
RETURN(fsdb);
err:
static void mgs_free_fsdb(struct mgs_device *mgs, struct fs_db *fsdb)
{
- /* wait for anyone with the sem */
+ /* wait for anyone with the sem */
mutex_lock(&fsdb->fsdb_mutex);
lproc_mgs_del_live(mgs, fsdb);
- cfs_list_del(&fsdb->fsdb_list);
+ list_del(&fsdb->fsdb_list);
/* deinitialize fsr */
mgs_ir_fini_fs(mgs, fsdb);
int mgs_init_fsdb_list(struct mgs_device *mgs)
{
- CFS_INIT_LIST_HEAD(&mgs->mgs_fs_db_list);
+ INIT_LIST_HEAD(&mgs->mgs_fs_db_list);
return 0;
}
int mgs_cleanup_fsdb_list(struct mgs_device *mgs)
{
- struct fs_db *fsdb;
- cfs_list_t *tmp, *tmp2;
+ struct fs_db *fsdb;
+ struct list_head *tmp, *tmp2;
+
mutex_lock(&mgs->mgs_mutex);
- cfs_list_for_each_safe(tmp, tmp2, &mgs->mgs_fs_db_list) {
- fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
+ list_for_each_safe(tmp, tmp2, &mgs->mgs_fs_db_list) {
+ fsdb = list_entry(tmp, struct fs_db, fsdb_list);
mgs_free_fsdb(mgs, fsdb);
- }
+ }
mutex_unlock(&mgs->mgs_mutex);
- return 0;
+ return 0;
}
int mgs_find_or_make_fsdb(const struct lu_env *env,
fsdb->fsdb_mdt_count ++;
}
- if (mti->mti_stripe_index >= INDEX_MAP_SIZE * 8) {
- LCONSOLE_ERROR_MSG(0x13f, "Server %s requested index %d, "
- "but the max index is %d.\n",
- mti->mti_svname, mti->mti_stripe_index,
- INDEX_MAP_SIZE * 8);
+ /* the last index(0xffff) is reserved for default value. */
+ if (mti->mti_stripe_index >= INDEX_MAP_SIZE * 8 - 1) {
+ LCONSOLE_ERROR_MSG(0x13f, "Server %s requested index %u, "
+ "but index must be less than %u.\n",
+ mti->mti_svname, mti->mti_stripe_index,
+ INDEX_MAP_SIZE * 8 - 1);
GOTO(out_up, rc = -ERANGE);
- }
+ }
if (test_bit(mti->mti_stripe_index, imap)) {
if ((mti->mti_flags & LDD_F_VIRGIN) &&
marker->cm_flags &= ~CM_EXCLUDE; /* in case we're unexcluding */
marker->cm_flags |= mml->mml_marker.cm_flags;
marker->cm_canceltime = mml->mml_marker.cm_canceltime;
- /* Header and tail are added back to lrh_len in
- llog_lvfs_write_rec */
- rec->lrh_len = cfg_len;
- rc = llog_write(env, llh, rec, NULL, 0, (void *)lcfg,
- rec->lrh_index);
+ rc = llog_write(env, llh, rec, rec->lrh_index);
if (!rc)
mml->mml_modified++;
}
OBD_ALLOC_PTR(mml);
if (!mml)
GOTO(out_close, rc = -ENOMEM);
- strcpy(mml->mml_marker.cm_comment, comment);
- strcpy(mml->mml_marker.cm_tgtname, devname);
+ if (strlcpy(mml->mml_marker.cm_comment, comment,
+ sizeof(mml->mml_marker.cm_comment)) >=
+ sizeof(mml->mml_marker.cm_comment))
+ GOTO(out_free, rc = -E2BIG);
+ if (strlcpy(mml->mml_marker.cm_tgtname, devname,
+ sizeof(mml->mml_marker.cm_tgtname)) >=
+ sizeof(mml->mml_marker.cm_tgtname))
+ GOTO(out_free, rc = -E2BIG);
/* Modify mostly means cancel */
mml->mml_marker.cm_flags = flags;
mml->mml_marker.cm_canceltime = flags ? cfs_time_current_sec() : 0;
NULL);
if (!rc && !mml->mml_modified)
rc = 1;
+
+out_free:
OBD_FREE_PTR(mml);
out_close:
return 0;
}
-static int record_lcfg(const struct lu_env *env, struct llog_handle *llh,
- struct lustre_cfg *lcfg)
-{
- struct llog_rec_hdr rec;
- int buflen, rc;
-
- if (!lcfg || !llh)
- return -ENOMEM;
-
- LASSERT(llh->lgh_ctxt);
-
- buflen = lustre_cfg_len(lcfg->lcfg_bufcount,
- lcfg->lcfg_buflens);
- rec.lrh_len = llog_data_len(buflen);
- rec.lrh_type = OBD_CFG_REC;
-
- /* idx = -1 means append */
- rc = llog_write(env, llh, &rec, NULL, 0, (void *)lcfg, -1);
- if (rc)
- CERROR("failed %d\n", rc);
- return rc;
-}
-
static int record_base(const struct lu_env *env, struct llog_handle *llh,
char *cfgname, lnet_nid_t nid, int cmd,
char *s1, char *s2, char *s3, char *s4)
{
- struct mgs_thread_info *mgi = mgs_env_info(env);
- struct lustre_cfg *lcfg;
+ struct mgs_thread_info *mgi = mgs_env_info(env);
+ struct llog_cfg_rec *lcr;
int rc;
CDEBUG(D_MGS, "lcfg %s %#x %s %s %s %s\n", cfgname,
if (s4)
lustre_cfg_bufs_set_string(&mgi->mgi_bufs, 4, s4);
- lcfg = lustre_cfg_new(cmd, &mgi->mgi_bufs);
- if (!lcfg)
+ lcr = lustre_cfg_rec_new(cmd, &mgi->mgi_bufs);
+ if (lcr == NULL)
return -ENOMEM;
- lcfg->lcfg_nid = nid;
- rc = record_lcfg(env, llh, lcfg);
+ lcr->lcr_cfg.lcfg_nid = nid;
+ rc = llog_write(env, llh, &lcr->lcr_hdr, LLOG_NEXT_IDX);
- lustre_cfg_free(lcfg);
+ lustre_cfg_rec_free(lcr);
- if (rc) {
- CERROR("error %d: lcfg %s %#x %s %s %s %s\n", rc, cfgname,
- cmd, s1, s2, s3, s4);
- }
+ if (rc < 0)
+ CDEBUG(D_MGS,
+ "failed to write lcfg %s %#x %s %s %s %s: rc = %d\n",
+ cfgname, cmd, s1, s2, s3, s4, rc);
return rc;
}
RETURN(0);
copy_out:
/* Record is placed in temporary llog as is */
- rc = llog_write(env, mrul->temp_llh, rec, NULL, 0, NULL, -1);
+ rc = llog_write(env, mrul->temp_llh, rec, LLOG_NEXT_IDX);
CDEBUG(D_MGS, "Copied idx=%d, rc=%d, len=%d, cmd %x %s %s\n",
rec->lrh_index, rc, rec->lrh_len, lcfg->lcfg_command,
if (!mrul)
GOTO(out_close, rc = -ENOMEM);
/* devname is only needed information to replace UUID records */
- strncpy(mrul->target.mti_svname, devname, MTI_NAME_MAXLEN);
+ strlcpy(mrul->target.mti_svname, devname,
+ sizeof(mrul->target.mti_svname));
/* parse nids later */
- strncpy(mrul->target.mti_params, nids, MTI_PARAM_MAXLEN);
+ strlcpy(mrul->target.mti_params, nids, sizeof(mrul->target.mti_params));
/* Copy records to this temporary llog */
mrul->temp_llh = orig_llh;
RETURN(0);
}
+/* This is only called during replace_nids */
static int only_mgs_is_running(struct obd_device *mgs_obd)
{
/* TDB: Is global variable with devices count exists? */
int num_devices = get_devices_count();
+ int num_exports = 0;
+ struct obd_export *exp;
+
+ spin_lock(&mgs_obd->obd_dev_lock);
+ list_for_each_entry(exp, &mgs_obd->obd_exports, exp_obd_chain) {
+ /* skip self export */
+ if (exp == mgs_obd->obd_self_export)
+ continue;
+ if (exp_connect_flags(exp) & OBD_CONNECT_MDS_MDS)
+ continue;
+
+ ++num_exports;
+
+ CERROR("%s: node %s still connected during replace_nids "
+ "connect_flags:%llx\n",
+ mgs_obd->obd_name,
+ libcfs_nid2str(exp->exp_nid_stats->nid),
+ exp_connect_flags(exp));
+
+ }
+ spin_unlock(&mgs_obd->obd_dev_lock);
+
/* osd, MGS and MGC + self_export
- (wc -l /proc/fs/lustre/devices <= 2) && (num_exports <= 2) */
- return (num_devices <= 3) && (mgs_obd->obd_num_exports <= 2);
+ (wc -l /proc/fs/lustre/devices <= 2) && (non self exports == 0) */
+ return (num_devices <= 3) && (num_exports == 0);
}
static int name_create_mdt(char **logname, char *fsname, int i)
static int record_lov_setup(const struct lu_env *env, struct llog_handle *llh,
char *devname, struct lov_desc *desc)
{
- struct mgs_thread_info *mgi = mgs_env_info(env);
- struct lustre_cfg *lcfg;
+ struct mgs_thread_info *mgi = mgs_env_info(env);
+ struct llog_cfg_rec *lcr;
int rc;
lustre_cfg_bufs_reset(&mgi->mgi_bufs, devname);
lustre_cfg_bufs_set(&mgi->mgi_bufs, 1, desc, sizeof(*desc));
- lcfg = lustre_cfg_new(LCFG_SETUP, &mgi->mgi_bufs);
- if (!lcfg)
+ lcr = lustre_cfg_rec_new(LCFG_SETUP, &mgi->mgi_bufs);
+ if (lcr == NULL)
return -ENOMEM;
- rc = record_lcfg(env, llh, lcfg);
- lustre_cfg_free(lcfg);
+ rc = llog_write(env, llh, &lcr->lcr_hdr, LLOG_NEXT_IDX);
+ lustre_cfg_rec_free(lcr);
return rc;
}
static int record_lmv_setup(const struct lu_env *env, struct llog_handle *llh,
char *devname, struct lmv_desc *desc)
{
- struct mgs_thread_info *mgi = mgs_env_info(env);
- struct lustre_cfg *lcfg;
+ struct mgs_thread_info *mgi = mgs_env_info(env);
+ struct llog_cfg_rec *lcr;
int rc;
lustre_cfg_bufs_reset(&mgi->mgi_bufs, devname);
lustre_cfg_bufs_set(&mgi->mgi_bufs, 1, desc, sizeof(*desc));
- lcfg = lustre_cfg_new(LCFG_SETUP, &mgi->mgi_bufs);
-
- rc = record_lcfg(env, llh, lcfg);
+ lcr = lustre_cfg_rec_new(LCFG_SETUP, &mgi->mgi_bufs);
+ if (lcr == NULL)
+ return -ENOMEM;
- lustre_cfg_free(lcfg);
+ rc = llog_write(env, llh, &lcr->lcr_hdr, LLOG_NEXT_IDX);
+ lustre_cfg_rec_free(lcr);
return rc;
}
char *tgtname, char *comment)
{
struct mgs_thread_info *mgi = mgs_env_info(env);
- struct lustre_cfg *lcfg;
+ struct llog_cfg_rec *lcr;
int rc;
int cplen = 0;
lustre_cfg_bufs_reset(&mgi->mgi_bufs, NULL);
lustre_cfg_bufs_set(&mgi->mgi_bufs, 1, &mgi->mgi_marker,
sizeof(mgi->mgi_marker));
- lcfg = lustre_cfg_new(LCFG_MARKER, &mgi->mgi_bufs);
- if (!lcfg)
+ lcr = lustre_cfg_rec_new(LCFG_MARKER, &mgi->mgi_bufs);
+ if (lcr == NULL)
return -ENOMEM;
- rc = record_lcfg(env, llh, lcfg);
- lustre_cfg_free(lcfg);
+ rc = llog_write(env, llh, &lcr->lcr_hdr, LLOG_NEXT_IDX);
+ lustre_cfg_rec_free(lcr);
return rc;
}
static struct obd_uuid cfg_uuid = { .uuid = "config_uuid" };
struct llog_ctxt *ctxt;
int rc = 0;
+ ENTRY;
if (*llh)
GOTO(out, rc = -EBUSY);
/* write an lcfg directly into a log (with markers) */
static int mgs_write_log_direct(const struct lu_env *env,
struct mgs_device *mgs, struct fs_db *fsdb,
- char *logname, struct lustre_cfg *lcfg,
- char *devname, char *comment)
+ char *logname, struct llog_cfg_rec *lcr,
+ char *devname, char *comment)
{
- struct llog_handle *llh = NULL;
- int rc;
- ENTRY;
+ struct llog_handle *llh = NULL;
+ int rc;
- if (!lcfg)
- RETURN(-ENOMEM);
+ ENTRY;
rc = record_start_log(env, mgs, &llh, logname);
- if (rc)
- RETURN(rc);
+ if (rc)
+ RETURN(rc);
/* FIXME These should be a single journal transaction */
rc = record_marker(env, llh, fsdb, CM_START, devname, comment);
if (rc)
GOTO(out_end, rc);
- rc = record_lcfg(env, llh, lcfg);
+ rc = llog_write(env, llh, &lcr->lcr_hdr, LLOG_NEXT_IDX);
if (rc)
GOTO(out_end, rc);
rc = record_marker(env, llh, fsdb, CM_END, devname, comment);
}
/* write the lcfg in all logs for the given fs */
-int mgs_write_log_direct_all(const struct lu_env *env,
- struct mgs_device *mgs,
- struct fs_db *fsdb,
- struct mgs_target_info *mti,
- struct lustre_cfg *lcfg,
- char *devname, char *comment,
- int server_only)
+static int mgs_write_log_direct_all(const struct lu_env *env,
+ struct mgs_device *mgs,
+ struct fs_db *fsdb,
+ struct mgs_target_info *mti,
+ struct llog_cfg_rec *lcr, char *devname,
+ char *comment, int server_only)
{
- cfs_list_t list;
- struct mgs_direntry *dirent, *n;
- char *fsname = mti->mti_fsname;
- char *logname;
- int rc = 0, len = strlen(fsname);
- ENTRY;
+ struct list_head log_list;
+ struct mgs_direntry *dirent, *n;
+ char *fsname = mti->mti_fsname;
+ int rc = 0, len = strlen(fsname);
- /* We need to set params for any future logs
- as well. FIXME Append this file to every new log.
- Actually, we should store as params (text), not llogs. Or
- in a database. */
- rc = name_create(&logname, fsname, "-params");
+ ENTRY;
+ /* Find all the logs in the CONFIGS directory */
+ rc = class_dentry_readdir(env, mgs, &log_list);
if (rc)
RETURN(rc);
- if (mgs_log_is_empty(env, mgs, logname)) {
- struct llog_handle *llh = NULL;
- rc = record_start_log(env, mgs, &llh, logname);
- record_end_log(env, &llh);
- }
- name_destroy(&logname);
- if (rc)
- RETURN(rc);
-
- /* Find all the logs in the CONFIGS directory */
- rc = class_dentry_readdir(env, mgs, &list);
- if (rc)
- RETURN(rc);
- /* Could use fsdb index maps instead of directory listing */
- cfs_list_for_each_entry_safe(dirent, n, &list, list) {
- cfs_list_del(&dirent->list);
- /* don't write to sptlrpc rule log */
- if (strstr(dirent->name, "-sptlrpc") != NULL)
+ /* Could use fsdb index maps instead of directory listing */
+ list_for_each_entry_safe(dirent, n, &log_list, mde_list) {
+ list_del_init(&dirent->mde_list);
+ /* don't write to sptlrpc rule log */
+ if (strstr(dirent->mde_name, "-sptlrpc") != NULL)
goto next;
/* caller wants write server logs only */
- if (server_only && strstr(dirent->name, "-client") != NULL)
+ if (server_only && strstr(dirent->mde_name, "-client") != NULL)
goto next;
- if (strncmp(fsname, dirent->name, len) == 0) {
- CDEBUG(D_MGS, "Changing log %s\n", dirent->name);
- /* Erase any old settings of this same parameter */
- rc = mgs_modify(env, mgs, fsdb, mti, dirent->name,
- devname, comment, CM_SKIP);
- if (rc < 0)
- CERROR("%s: Can't modify llog %s: rc = %d\n",
- mgs->mgs_obd->obd_name, dirent->name,rc);
- /* Write the new one */
- if (lcfg) {
- rc = mgs_write_log_direct(env, mgs, fsdb,
- dirent->name,
- lcfg, devname,
- comment);
- if (rc)
- CERROR("%s: writing log %s: rc = %d\n",
- mgs->mgs_obd->obd_name,
- dirent->name, rc);
- }
- }
+ if (strlen(dirent->mde_name) <= len ||
+ strncmp(fsname, dirent->mde_name, len) != 0 ||
+ dirent->mde_name[len] != '-')
+ goto next;
+
+ CDEBUG(D_MGS, "Changing log %s\n", dirent->mde_name);
+ /* Erase any old settings of this same parameter */
+ rc = mgs_modify(env, mgs, fsdb, mti, dirent->mde_name,
+ devname, comment, CM_SKIP);
+ if (rc < 0)
+ CERROR("%s: Can't modify llog %s: rc = %d\n",
+ mgs->mgs_obd->obd_name, dirent->mde_name, rc);
+ if (lcr == NULL)
+ goto next;
+ /* Write the new one */
+ rc = mgs_write_log_direct(env, mgs, fsdb, dirent->mde_name,
+ lcr, devname, comment);
+ if (rc != 0)
+ CERROR("%s: writing log %s: rc = %d\n",
+ mgs->mgs_obd->obd_name, dirent->mde_name, rc);
next:
mgs_direntry_free(dirent);
- }
+ }
- RETURN(rc);
+ RETURN(rc);
}
static int mgs_write_log_osp_to_mdt(const struct lu_env *env,
/* Defaults. Can be changed later by lcfg config_param */
lovdesc->ld_default_stripe_count = 1;
lovdesc->ld_pattern = LOV_PATTERN_RAID0;
- lovdesc->ld_default_stripe_size = 1024 * 1024;
+ lovdesc->ld_default_stripe_size = LOV_DESC_STRIPE_SIZE_DEFAULT;
lovdesc->ld_default_stripe_offset = -1;
- lovdesc->ld_qos_maxage = QOS_DEFAULT_MAXAGE;
+ lovdesc->ld_qos_maxage = LOV_DESC_QOS_MAXAGE_DEFAULT;
sprintf((char*)lovdesc->ld_uuid.uuid, "%s_UUID", lovname);
/* can these be the same? */
uuid = (char *)lovdesc->ld_uuid.uuid;
#07 L add_conn 0:OSC_uml1_ost1_mdsA 1:uml2_UUID
*/
- /* Pull failnid info out of params string */
+ /*
+ * Pull failnid info out of params string, which may contain something
+ * like "<nid1>,<nid2>:<nid3>,<nid4>". class_parse_nid() does not
+ * complain about abnormal inputs like ",:<nid1>", "<nid1>:,<nid2>",
+ * etc. However, convert_hostnames() should have caught those.
+ */
while (class_find_param(ptr, PARAM_FAILNODE, &ptr) == 0) {
while (class_parse_nid(ptr, &nid, &ptr) == 0) {
if (failnodeuuid == NULL) {
"client %s\n", libcfs_nid2str(nid),
failnodeuuid, cliname);
rc = record_add_uuid(env, llh, nid, failnodeuuid);
- }
- if (failnodeuuid)
+ /*
+ * If *ptr is ':', we have added all NIDs for
+ * failnodeuuid.
+ */
+ if (*ptr == ':') {
+ rc = record_add_conn(env, llh, cliname,
+ failnodeuuid);
+ name_destroy(&failnodeuuid);
+ failnodeuuid = NULL;
+ }
+ }
+ if (failnodeuuid) {
rc = record_add_conn(env, llh, cliname, failnodeuuid);
- }
+ name_destroy(&failnodeuuid);
+ failnodeuuid = NULL;
+ }
+ }
- name_destroy(&failnodeuuid);
- return rc;
+ return rc;
}
static int mgs_write_log_mdc_to_lmv(const struct lu_env *env,
static int mgs_wlp_lcfg(const struct lu_env *env,
struct mgs_device *mgs, struct fs_db *fsdb,
- struct mgs_target_info *mti,
- char *logname, struct lustre_cfg_bufs *bufs,
- char *tgtname, char *ptr)
+ struct mgs_target_info *mti,
+ char *logname, struct lustre_cfg_bufs *bufs,
+ char *tgtname, char *ptr)
{
- char comment[MTI_NAME_MAXLEN];
- char *tmp;
- struct lustre_cfg *lcfg;
- int rc, del;
-
- /* Erase any old settings of this same parameter */
- memcpy(comment, ptr, MTI_NAME_MAXLEN);
- comment[MTI_NAME_MAXLEN - 1] = 0;
- /* But don't try to match the value. */
- if ((tmp = strchr(comment, '=')))
- *tmp = 0;
- /* FIXME we should skip settings that are the same as old values */
+ char comment[MTI_NAME_MAXLEN];
+ char *tmp;
+ struct llog_cfg_rec *lcr;
+ int rc, del;
+
+ /* Erase any old settings of this same parameter */
+ memcpy(comment, ptr, MTI_NAME_MAXLEN);
+ comment[MTI_NAME_MAXLEN - 1] = 0;
+ /* But don't try to match the value. */
+ tmp = strchr(comment, '=');
+ if (tmp != NULL)
+ *tmp = 0;
+ /* FIXME we should skip settings that are the same as old values */
rc = mgs_modify(env, mgs, fsdb, mti, logname, tgtname, comment,CM_SKIP);
if (rc < 0)
return rc;
- del = mgs_param_empty(ptr);
+ del = mgs_param_empty(ptr);
- LCONSOLE_INFO("%sing parameter %s.%s in log %s\n", del ? "Disabl" : rc ?
- "Sett" : "Modify", tgtname, comment, logname);
- if (del)
- return rc;
+ LCONSOLE_INFO("%s parameter %s.%s in log %s\n", del ? "Disabling" : rc ?
+ "Setting" : "Modifying", tgtname, comment, logname);
+ if (del) {
+ /* mgs_modify() will return 1 if nothing had to be done */
+ if (rc == 1)
+ rc = 0;
+ return rc;
+ }
- lustre_cfg_bufs_reset(bufs, tgtname);
+ lustre_cfg_bufs_reset(bufs, tgtname);
lustre_cfg_bufs_set_string(bufs, 1, ptr);
if (mti->mti_flags & LDD_F_PARAM2)
lustre_cfg_bufs_set_string(bufs, 2, LCTL_UPCALL);
- lcfg = lustre_cfg_new((mti->mti_flags & LDD_F_PARAM2) ?
- LCFG_SET_PARAM : LCFG_PARAM, bufs);
+ lcr = lustre_cfg_rec_new((mti->mti_flags & LDD_F_PARAM2) ?
+ LCFG_SET_PARAM : LCFG_PARAM, bufs);
+ if (lcr == NULL)
+ return -ENOMEM;
- if (!lcfg)
- return -ENOMEM;
- rc = mgs_write_log_direct(env, mgs, fsdb, logname,lcfg,tgtname,comment);
- lustre_cfg_free(lcfg);
- return rc;
+ rc = mgs_write_log_direct(env, mgs, fsdb, logname, lcr, tgtname,
+ comment);
+ lustre_cfg_rec_free(lcr);
+ return rc;
}
static int mgs_write_log_param2(const struct lu_env *env,
struct mgs_device *mgs, struct fs_db *fsdb,
struct mgs_target_info *mti, char *sys, char *ptr)
{
- struct mgs_thread_info *mgi = mgs_env_info(env);
- struct lustre_cfg *lcfg;
+ struct mgs_thread_info *mgi = mgs_env_info(env);
+ struct lustre_cfg *lcfg;
+ struct llog_cfg_rec *lcr;
char *tmp, sep;
int rc, cmd, convert = 1;
lustre_cfg_bufs_set_string(&mgi->mgi_bufs, 1, sys);
if (!convert && *tmp != '\0')
lustre_cfg_bufs_set_string(&mgi->mgi_bufs, 2, tmp);
- lcfg = lustre_cfg_new(cmd, &mgi->mgi_bufs);
+ lcr = lustre_cfg_rec_new(cmd, &mgi->mgi_bufs);
+ if (lcr == NULL)
+ return -ENOMEM;
+
+ lcfg = &lcr->lcr_cfg;
lcfg->lcfg_num = convert ? simple_strtoul(tmp, NULL, 0) : 0;
/* truncate the comment to the parameter name */
ptr = tmp - 1;
*ptr = '\0';
/* modify all servers and clients */
rc = mgs_write_log_direct_all(env, mgs, fsdb, mti,
- *tmp == '\0' ? NULL : lcfg,
+ *tmp == '\0' ? NULL : lcr,
mti->mti_fsname, sys, 0);
if (rc == 0 && *tmp != '\0') {
switch (cmd) {
}
}
*ptr = sep;
- lustre_cfg_free(lcfg);
+ lustre_cfg_rec_free(lcr);
return rc;
}
char *quota, char *ptr)
{
struct mgs_thread_info *mgi = mgs_env_info(env);
- struct lustre_cfg *lcfg;
+ struct llog_cfg_rec *lcr;
char *tmp;
char sep;
int rc, cmd = LCFG_PARAM;
lustre_cfg_bufs_reset(&mgi->mgi_bufs, mti->mti_fsname);
lustre_cfg_bufs_set_string(&mgi->mgi_bufs, 1, quota);
- lcfg = lustre_cfg_new(cmd, &mgi->mgi_bufs);
+ lcr = lustre_cfg_rec_new(cmd, &mgi->mgi_bufs);
+ if (lcr == NULL)
+ return -ENOMEM;
+
/* truncate the comment to the parameter name */
ptr = tmp - 1;
sep = *ptr;
* log once we cleanup the config log for global param. */
/* modify all servers */
rc = mgs_write_log_direct_all(env, mgs, fsdb, mti,
- *tmp == '\0' ? NULL : lcfg,
+ *tmp == '\0' ? NULL : lcr,
mti->mti_fsname, quota, 1);
*ptr = sep;
- lustre_cfg_free(lcfg);
+ lustre_cfg_rec_free(lcr);
return rc < 0 ? rc : 0;
}
struct mgs_target_info *mti,
char *param)
{
- struct mgs_thread_info *mgi = mgs_env_info(env);
- struct llog_handle *llh = NULL;
- char *logname;
- char *comment, *ptr;
- struct lustre_cfg *lcfg;
- int rc, len;
- ENTRY;
+ struct mgs_thread_info *mgi = mgs_env_info(env);
+ struct llog_cfg_rec *lcr;
+ struct llog_handle *llh = NULL;
+ char *logname;
+ char *comment, *ptr;
+ int rc, len;
- /* get comment */
- ptr = strchr(param, '=');
- LASSERT(ptr);
- len = ptr - param;
+ ENTRY;
- OBD_ALLOC(comment, len + 1);
- if (comment == NULL)
- RETURN(-ENOMEM);
- strncpy(comment, param, len);
- comment[len] = '\0';
+ /* get comment */
+ ptr = strchr(param, '=');
+ LASSERT(ptr != NULL);
+ len = ptr - param;
+
+ OBD_ALLOC(comment, len + 1);
+ if (comment == NULL)
+ RETURN(-ENOMEM);
+ strncpy(comment, param, len);
+ comment[len] = '\0';
- /* prepare lcfg */
+ /* prepare lcfg */
lustre_cfg_bufs_reset(&mgi->mgi_bufs, mti->mti_svname);
lustre_cfg_bufs_set_string(&mgi->mgi_bufs, 1, param);
- lcfg = lustre_cfg_new(LCFG_SPTLRPC_CONF, &mgi->mgi_bufs);
- if (lcfg == NULL)
- GOTO(out_comment, rc = -ENOMEM);
+ lcr = lustre_cfg_rec_new(LCFG_SPTLRPC_CONF, &mgi->mgi_bufs);
+ if (lcr == NULL)
+ GOTO(out_comment, rc = -ENOMEM);
- /* construct log name */
- rc = name_create(&logname, mti->mti_fsname, "-sptlrpc");
- if (rc)
- GOTO(out_lcfg, rc);
+ /* construct log name */
+ rc = name_create(&logname, mti->mti_fsname, "-sptlrpc");
+ if (rc < 0)
+ GOTO(out_lcfg, rc);
if (mgs_log_is_empty(env, mgs, logname)) {
rc = record_start_log(env, mgs, &llh, logname);
- if (rc)
- GOTO(out, rc);
+ if (rc < 0)
+ GOTO(out, rc);
record_end_log(env, &llh);
- }
+ }
- /* obsolete old one */
+ /* obsolete old one */
rc = mgs_modify(env, mgs, fsdb, mti, logname, mti->mti_svname,
comment, CM_SKIP);
if (rc < 0)
GOTO(out, rc);
- /* write the new one */
- rc = mgs_write_log_direct(env, mgs, fsdb, logname, lcfg,
- mti->mti_svname, comment);
+ /* write the new one */
+ rc = mgs_write_log_direct(env, mgs, fsdb, logname, lcr,
+ mti->mti_svname, comment);
if (rc)
- CERROR("err %d writing log %s\n", rc, logname);
+ CERROR("%s: error writing log %s: rc = %d\n",
+ mgs->mgs_obd->obd_name, logname, rc);
out:
- name_destroy(&logname);
+ name_destroy(&logname);
out_lcfg:
- lustre_cfg_free(lcfg);
+ lustre_cfg_rec_free(lcr);
out_comment:
- OBD_FREE(comment, len + 1);
- RETURN(rc);
+ OBD_FREE(comment, len + 1);
+ RETURN(rc);
}
static int mgs_srpc_set_param_udesc_mem(struct fs_db *fsdb,
RETURN(-EINVAL);
}
- cfg_len = rec->lrh_len - sizeof(struct llog_rec_hdr) -
- sizeof(struct llog_rec_tail);
+ cfg_len = REC_DATA_LEN(rec);
rc = lustre_cfg_sanity_check(lcfg, cfg_len);
if (rc) {
if (rc)
GOTO(end, rc);
- CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
+ /* Forbid direct update of llite root squash parameters.
+ * These parameters are indirectly set via the MDT settings.
+ * See (LU-1778) */
+ if ((class_match_param(ptr, PARAM_LLITE, &tmp) == 0) &&
+ ((memcmp(tmp, "root_squash=", 12) == 0) ||
+ (memcmp(tmp, "nosquash_nids=", 14) == 0))) {
+ LCONSOLE_ERROR("%s: root squash parameters can only "
+ "be updated through MDT component\n",
+ mti->mti_fsname);
+ name_destroy(&cname);
+ GOTO(end, rc = -EINVAL);
+ }
+
+ CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
- /* Modify client */
+ /* Modify client */
rc = name_create(&logname, mti->mti_fsname, "-client");
if (rc) {
name_destroy(&cname);
}
}
}
- name_destroy(&logname);
- name_destroy(&cname);
- GOTO(end, rc);
- }
+ name_destroy(&logname);
+ name_destroy(&cname);
+ GOTO(end, rc);
+ }
- /* All mdt. params in proc */
- if (class_match_param(ptr, PARAM_MDT, NULL) == 0) {
+ /* All mdt. params in proc */
+ if (class_match_param(ptr, PARAM_MDT, &tmp) == 0) {
int i;
__u32 idx;
goto active_err;
rc = mgs_wlp_lcfg(env, mgs, fsdb, mti,
logname, &mgi->mgi_bufs,
- logname, ptr);
- name_destroy(&logname);
- if (rc)
- goto active_err;
- }
- } else {
+ logname, ptr);
+ name_destroy(&logname);
+ if (rc)
+ goto active_err;
+ }
+ } else {
+ if ((memcmp(tmp, "root_squash=", 12) == 0) ||
+ (memcmp(tmp, "nosquash_nids=", 14) == 0)) {
+ LCONSOLE_ERROR("%s: root squash parameters "
+ "cannot be applied to a single MDT\n",
+ mti->mti_fsname);
+ GOTO(end, rc = -EINVAL);
+ }
rc = mgs_wlp_lcfg(env, mgs, fsdb, mti,
mti->mti_svname, &mgi->mgi_bufs,
- mti->mti_svname, ptr);
- if (rc)
- goto active_err;
- }
- GOTO(end, rc);
- }
+ mti->mti_svname, ptr);
+ if (rc)
+ goto active_err;
+ }
- /* All mdd., ost. params in proc */
- if ((class_match_param(ptr, PARAM_MDD, NULL) == 0) ||
- (class_match_param(ptr, PARAM_OST, NULL) == 0)) {
- CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
+ /* root squash settings are also applied to llite
+ * config log (see LU-1778) */
+ if (rc == 0 &&
+ ((memcmp(tmp, "root_squash=", 12) == 0) ||
+ (memcmp(tmp, "nosquash_nids=", 14) == 0))) {
+ char *cname;
+ char *ptr2;
+
+ rc = name_create(&cname, mti->mti_fsname, "-client");
+ if (rc)
+ GOTO(end, rc);
+ rc = name_create(&logname, mti->mti_fsname, "-client");
+ if (rc) {
+ name_destroy(&cname);
+ GOTO(end, rc);
+ }
+ rc = name_create(&ptr2, PARAM_LLITE, tmp);
+ if (rc) {
+ name_destroy(&cname);
+ name_destroy(&logname);
+ GOTO(end, rc);
+ }
+ rc = mgs_wlp_lcfg(env, mgs, fsdb, mti, logname,
+ &mgi->mgi_bufs, cname, ptr2);
+ name_destroy(&ptr2);
+ name_destroy(&logname);
+ name_destroy(&cname);
+ }
+ GOTO(end, rc);
+ }
+
+ /* All mdd., ost. and osd. params in proc */
+ if ((class_match_param(ptr, PARAM_MDD, NULL) == 0) ||
+ (class_match_param(ptr, PARAM_OST, NULL) == 0) ||
+ (class_match_param(ptr, PARAM_OSD, NULL) == 0)) {
+ CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
if (mgs_log_is_empty(env, mgs, mti->mti_svname))
- GOTO(end, rc = -ENODEV);
+ GOTO(end, rc = -ENODEV);
rc = mgs_wlp_lcfg(env, mgs, fsdb, mti, mti->mti_svname,
&mgi->mgi_bufs, mti->mti_svname, ptr);
- GOTO(end, rc);
- }
+ GOTO(end, rc);
+ }
LCONSOLE_WARN("Ignoring unrecognized param '%s'\n", ptr);
rc2 = -ENOSYS;
mutex_lock(&fsdb->fsdb_mutex);
rc = mgs_write_log_add_failnid(obd, fsdb, mti);
mutex_unlock(&fsdb->fsdb_mutex);
+ char *buf, *params;
+ int rc = -EINVAL;
RETURN(rc);
#endif
return 0;
}
-int mgs_write_log_target(const struct lu_env *env,
- struct mgs_device *mgs,
- struct mgs_target_info *mti,
- struct fs_db *fsdb)
+int mgs_write_log_target(const struct lu_env *env, struct mgs_device *mgs,
+ struct mgs_target_info *mti, struct fs_db *fsdb)
{
- int rc = -EINVAL;
- char *buf, *params;
- ENTRY;
+ char *buf, *params;
+ int rc = -EINVAL;
+
+ ENTRY;
- /* set/check the new target index */
+ /* set/check the new target index */
rc = mgs_set_index(env, mgs, mti);
- if (rc < 0) {
- CERROR("Can't get index (%d)\n", rc);
- RETURN(rc);
- }
+ if (rc < 0)
+ RETURN(rc);
if (rc == EALREADY) {
LCONSOLE_WARN("Found index %d for %s, updating log\n",
int mgs_erase_logs(const struct lu_env *env, struct mgs_device *mgs, char *fsname)
{
struct fs_db *fsdb;
- cfs_list_t list;
+ struct list_head log_list;
struct mgs_direntry *dirent, *n;
int rc, len = strlen(fsname);
char *suffix;
ENTRY;
/* Find all the logs in the CONFIGS directory */
- rc = class_dentry_readdir(env, mgs, &list);
+ rc = class_dentry_readdir(env, mgs, &log_list);
if (rc)
RETURN(rc);
mutex_unlock(&mgs->mgs_mutex);
- cfs_list_for_each_entry_safe(dirent, n, &list, list) {
- cfs_list_del(&dirent->list);
- suffix = strrchr(dirent->name, '-');
+ list_for_each_entry_safe(dirent, n, &log_list, mde_list) {
+ list_del_init(&dirent->mde_list);
+ suffix = strrchr(dirent->mde_name, '-');
if (suffix != NULL) {
- if ((len == suffix - dirent->name) &&
- (strncmp(fsname, dirent->name, len) == 0)) {
+ if ((len == suffix - dirent->mde_name) &&
+ (strncmp(fsname, dirent->mde_name, len) == 0)) {
CDEBUG(D_MGS, "Removing log %s\n",
- dirent->name);
- mgs_erase_log(env, mgs, dirent->name);
+ dirent->mde_name);
+ mgs_erase_log(env, mgs, dirent->mde_name);
}
}
mgs_direntry_free(dirent);
RETURN(rc);
}
+/* list all logs for the given fs */
+int mgs_list_logs(const struct lu_env *env, struct mgs_device *mgs,
+ struct obd_ioctl_data *data)
+{
+ struct list_head log_list;
+ struct mgs_direntry *dirent, *n;
+ char *out, *suffix;
+ int l, remains, rc;
+
+ ENTRY;
+
+ /* Find all the logs in the CONFIGS directory */
+ rc = class_dentry_readdir(env, mgs, &log_list);
+ if (rc)
+ RETURN(rc);
+
+ out = data->ioc_bulk;
+ remains = data->ioc_inllen1;
+ list_for_each_entry_safe(dirent, n, &log_list, mde_list) {
+ list_del_init(&dirent->mde_list);
+ suffix = strrchr(dirent->mde_name, '-');
+ if (suffix != NULL) {
+ l = snprintf(out, remains, "config log: $%s\n",
+ dirent->mde_name);
+ out += l;
+ remains -= l;
+ }
+ mgs_direntry_free(dirent);
+ if (remains <= 0)
+ break;
+ }
+ RETURN(rc);
+}
+
/* from llog_swab */
static void print_lustre_cfg(struct lustre_cfg *lcfg)
{
EXIT;
}
+/* Setup params fsdb and log
+ */
+int mgs_params_fsdb_setup(const struct lu_env *env, struct mgs_device *mgs,
+ struct fs_db *fsdb)
+{
+ struct llog_handle *params_llh = NULL;
+ int rc;
+ ENTRY;
+
+ rc = mgs_find_or_make_fsdb(env, mgs, PARAMS_FILENAME, &fsdb);
+ if (fsdb != NULL) {
+ mutex_lock(&fsdb->fsdb_mutex);
+ rc = record_start_log(env, mgs, ¶ms_llh, PARAMS_FILENAME);
+ if (rc == 0)
+ rc = record_end_log(env, ¶ms_llh);
+ mutex_unlock(&fsdb->fsdb_mutex);
+ }
+
+ RETURN(rc);
+}
+
+/* Cleanup params fsdb and log
+ */
+int mgs_params_fsdb_cleanup(const struct lu_env *env, struct mgs_device *mgs)
+{
+ return mgs_erase_logs(env, mgs, PARAMS_FILENAME);
+}
+
/* Set a permanent (config log) param for a target or fs
* \param lcfg buf0 may contain the device (testfs-MDT0000) name
* buf1 contains the single parameter
if (rc == 0 && !mgs_parse_devname(devname, NULL, &index)) {
/* param related to llite isn't allowed to set by OST or MDT */
if (rc == 0 && strncmp(param, PARAM_LLITE,
- sizeof(PARAM_LLITE)) == 0)
+ sizeof(PARAM_LLITE) - 1) == 0)
RETURN(-EINVAL);
} else {
/* assume devname is the fsname */
- memset(fsname, 0, MTI_NAME_MAXLEN);
- strncpy(fsname, devname, MTI_NAME_MAXLEN);
- fsname[MTI_NAME_MAXLEN - 1] = 0;
+ strlcpy(fsname, devname, MTI_NAME_MAXLEN);
}
CDEBUG(D_MGS, "setparam fs='%s' device='%s'\n", fsname, devname);
static int mgs_write_log_pool(const struct lu_env *env,
struct mgs_device *mgs, char *logname,
- struct fs_db *fsdb, char *lovname,
+ struct fs_db *fsdb, char *tgtname,
enum lcfg_command_type cmd,
- char *poolname, char *fsname,
+ char *fsname, char *poolname,
char *ostname, char *comment)
{
struct llog_handle *llh = NULL;
rc = record_start_log(env, mgs, &llh, logname);
if (rc)
return rc;
- rc = record_marker(env, llh, fsdb, CM_START, lovname, comment);
+ rc = record_marker(env, llh, fsdb, CM_START, tgtname, comment);
if (rc)
goto out;
- rc = record_base(env, llh, lovname, 0, cmd, poolname, fsname, ostname, 0);
+ rc = record_base(env, llh, tgtname, 0, cmd,
+ fsname, poolname, ostname, 0);
if (rc)
goto out;
- rc = record_marker(env, llh, fsdb, CM_END, lovname, comment);
+ rc = record_marker(env, llh, fsdb, CM_END, tgtname, comment);
out:
record_end_log(env, &llh);
return rc;
}
+int mgs_nodemap_cmd(const struct lu_env *env, struct mgs_device *mgs,
+ enum lcfg_command_type cmd, const char *nodemap_name,
+ char *param)
+{
+ lnet_nid_t nid[2];
+ __u32 idmap[2];
+ bool bool_switch;
+ __u32 int_id;
+ int rc = 0;
+ ENTRY;
+
+ switch (cmd) {
+ case LCFG_NODEMAP_ADD:
+ rc = nodemap_add(nodemap_name);
+ break;
+ case LCFG_NODEMAP_DEL:
+ rc = nodemap_del(nodemap_name);
+ break;
+ case LCFG_NODEMAP_ADD_RANGE:
+ rc = nodemap_parse_range(param, nid);
+ if (rc != 0)
+ break;
+ rc = nodemap_add_range(nodemap_name, nid);
+ break;
+ case LCFG_NODEMAP_DEL_RANGE:
+ rc = nodemap_parse_range(param, nid);
+ if (rc != 0)
+ break;
+ rc = nodemap_del_range(nodemap_name, nid);
+ break;
+ case LCFG_NODEMAP_ADMIN:
+ bool_switch = simple_strtoul(param, NULL, 10);
+ rc = nodemap_set_allow_root(nodemap_name, bool_switch);
+ break;
+ case LCFG_NODEMAP_TRUSTED:
+ bool_switch = simple_strtoul(param, NULL, 10);
+ rc = nodemap_set_trust_client_ids(nodemap_name, bool_switch);
+ break;
+ case LCFG_NODEMAP_SQUASH_UID:
+ int_id = simple_strtoul(param, NULL, 10);
+ rc = nodemap_set_squash_uid(nodemap_name, int_id);
+ break;
+ case LCFG_NODEMAP_SQUASH_GID:
+ int_id = simple_strtoul(param, NULL, 10);
+ rc = nodemap_set_squash_gid(nodemap_name, int_id);
+ break;
+ case LCFG_NODEMAP_ADD_UIDMAP:
+ case LCFG_NODEMAP_ADD_GIDMAP:
+ rc = nodemap_parse_idmap(param, idmap);
+ if (rc != 0)
+ break;
+ if (cmd == LCFG_NODEMAP_ADD_UIDMAP)
+ rc = nodemap_add_idmap(nodemap_name, NODEMAP_UID,
+ idmap);
+ else
+ rc = nodemap_add_idmap(nodemap_name, NODEMAP_GID,
+ idmap);
+ break;
+ case LCFG_NODEMAP_DEL_UIDMAP:
+ case LCFG_NODEMAP_DEL_GIDMAP:
+ rc = nodemap_parse_idmap(param, idmap);
+ if (rc != 0)
+ break;
+ if (cmd == LCFG_NODEMAP_DEL_UIDMAP)
+ rc = nodemap_del_idmap(nodemap_name, NODEMAP_UID,
+ idmap);
+ else
+ rc = nodemap_del_idmap(nodemap_name, NODEMAP_GID,
+ idmap);
+ break;
+ default:
+ rc = -EINVAL;
+ }
+
+ RETURN(rc);
+}
+
int mgs_pool_cmd(const struct lu_env *env, struct mgs_device *mgs,
enum lcfg_command_type cmd, char *fsname,
char *poolname, char *ostname)
git://git.whamcloud.com / fs / lustre-release.git / blobdiff