X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmgs%2Fmgs_llog.c;h=1fbc87d671cffe680d6667361cfe89b7023c96f3;hp=fb9ae688efb45adb4232e25a788e66ac12cec579;hb=bbe5f8ec92c63cc4fcb9ab0b316e92fb2a3d9683;hpb=723613a734af240e03d9e8b42afeba442a77142d

diff --git a/lustre/mgs/mgs_llog.c b/lustre/mgs/mgs_llog.c
index fb9ae68..1fbc87d 100644
--- a/lustre/mgs/mgs_llog.c
+++ b/lustre/mgs/mgs_llog.c
@@ -46,7 +46,7 @@
 #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>
@@ -55,8 +55,9 @@
 
 /********************** 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;
@@ -65,7 +66,7 @@ int class_dentry_readdir(const struct lu_env *env,
 	char		    *key;
 	int		     rc, key_sz;
 
-	CFS_INIT_LIST_HEAD(list);
+	INIT_LIST_HEAD(log_list);
 
 	LASSERT(dir);
 	LASSERT(dir->do_index_ops);
@@ -105,10 +106,10 @@ int class_dentry_readdir(const struct lu_env *env,
 			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);
@@ -313,10 +314,10 @@ static void mgs_free_fsdb_srpc(struct fs_db *fsdb)
 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;
         }
@@ -368,7 +369,7 @@ static struct fs_db *mgs_new_fsdb(const struct lu_env *env,
 		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:
@@ -384,10 +385,10 @@ 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);
@@ -405,21 +406,22 @@ static void mgs_free_fsdb(struct mgs_device *mgs, struct fs_db *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,
@@ -640,11 +642,7 @@ static int mgs_modify_handler(const struct lu_env *env,
                 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++;
         }
@@ -696,11 +694,11 @@ static int mgs_modify(const struct lu_env *env, struct mgs_device *mgs,
 	if (strlcpy(mml->mml_marker.cm_comment, comment,
 		    sizeof(mml->mml_marker.cm_comment)) >=
 	    sizeof(mml->mml_marker.cm_comment))
-		GOTO(out_close, rc = -E2BIG);
+		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_close, rc = -E2BIG);
+		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;
@@ -709,6 +707,8 @@ static int mgs_modify(const struct lu_env *env, struct mgs_device *mgs,
 			  NULL);
 	if (!rc && !mml->mml_modified)
 		rc = 1;
+
+out_free:
         OBD_FREE_PTR(mml);
 
 out_close:
@@ -782,35 +782,12 @@ static int check_markers(struct lustre_cfg *lcfg,
 	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,
@@ -826,19 +803,19 @@ static int record_base(const struct lu_env *env, struct llog_handle *llh,
 	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;
 }
 
@@ -995,7 +972,7 @@ static int mgs_replace_handler(const struct lu_env *env,
 		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,
@@ -1091,9 +1068,10 @@ static int mgs_replace_nids_log(const struct lu_env *env,
 	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;
 
@@ -1169,13 +1147,36 @@ static int mgs_parse_devname(char *devname, char *fsname, __u32 *index)
 	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)
@@ -1266,35 +1267,36 @@ out:
 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;
 }
 
@@ -1332,7 +1334,7 @@ static int record_marker(const struct lu_env *env,
                          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;
 
@@ -1354,12 +1356,12 @@ static int record_marker(const struct lu_env *env,
 	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;
 }
 
@@ -1369,6 +1371,7 @@ static int record_start_log(const struct lu_env *env, struct mgs_device *mgs,
 	static struct obd_uuid	 cfg_uuid = { .uuid = "config_uuid" };
 	struct llog_ctxt	*ctxt;
 	int			 rc = 0;
+	ENTRY;
 
 	if (*llh)
 		GOTO(out, rc = -EBUSY);
@@ -1410,25 +1413,23 @@ static int record_end_log(const struct lu_env *env, struct llog_handle **llh)
 /* 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);
@@ -1440,78 +1441,56 @@ out_end:
 }
 
 /* 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)
+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 (strncmp(fsname, dirent->mde_name, len) != 0)
+			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,
@@ -1851,9 +1830,9 @@ static int mgs_write_log_lov(const struct lu_env *env, struct mgs_device *mgs,
         /* 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;
@@ -1904,7 +1883,12 @@ static int mgs_write_log_failnids(const struct lu_env *env,
         #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) {
@@ -1919,13 +1903,25 @@ static int mgs_write_log_failnids(const struct lu_env *env,
                                "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,
@@ -2686,45 +2682,51 @@ static int mgs_write_log_add_failnid(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,
@@ -2748,8 +2750,9 @@ static int mgs_write_log_sys(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;
 
@@ -2780,7 +2783,11 @@ static int mgs_write_log_sys(const struct lu_env *env,
 	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;
@@ -2788,7 +2795,7 @@ static int mgs_write_log_sys(const struct lu_env *env,
 	*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) {
@@ -2805,7 +2812,7 @@ static int mgs_write_log_sys(const struct lu_env *env,
 		}
 	}
 	*ptr = sep;
-	lustre_cfg_free(lcfg);
+	lustre_cfg_rec_free(lcr);
 	return rc;
 }
 
@@ -2815,7 +2822,7 @@ static int mgs_write_log_quota(const struct lu_env *env, struct mgs_device *mgs,
 			       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;
@@ -2842,7 +2849,10 @@ static int mgs_write_log_quota(const struct lu_env *env, struct mgs_device *mgs,
 
 	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;
@@ -2853,10 +2863,10 @@ static int mgs_write_log_quota(const struct lu_env *env, struct mgs_device *mgs,
 	 *     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;
 }
 
@@ -2866,61 +2876,63 @@ static int mgs_srpc_set_param_disk(const struct lu_env *env,
                                    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,
@@ -3108,8 +3120,7 @@ static int mgs_srpc_read_handler(const struct lu_env *env,
                 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) {
@@ -3401,9 +3412,22 @@ static int mgs_write_log_param(const struct lu_env *env,
 		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);
+		}
 
-                /* Modify client */
+		CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
+
+		/* Modify client */
 		rc = name_create(&logname, mti->mti_fsname, "-client");
 		if (rc) {
 			name_destroy(&cname);
@@ -3439,13 +3463,13 @@ static int mgs_write_log_param(const struct lu_env *env,
 				}
 			}
 		}
-                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;
 
@@ -3471,32 +3495,69 @@ static int mgs_write_log_param(const struct lu_env *env,
 					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;
@@ -3534,27 +3595,26 @@ int mgs_check_failnid(const struct lu_env *env, struct mgs_device *mgs,
 	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;
 
-        /* set/check the new target index */
+	ENTRY;
+
+	/* 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",
@@ -3650,14 +3710,14 @@ int mgs_erase_log(const struct lu_env *env, struct mgs_device *mgs, char *name)
 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);
 
@@ -3670,15 +3730,15 @@ int mgs_erase_logs(const struct lu_env *env, struct mgs_device *mgs, char *fsnam
 
 	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);
@@ -3687,6 +3747,40 @@ int mgs_erase_logs(const struct lu_env *env, struct mgs_device *mgs, char *fsnam
         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)
 {
@@ -3711,6 +3805,34 @@ 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, &params_llh, PARAMS_FILENAME);
+		if (rc == 0)
+			rc = record_end_log(env, &params_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
@@ -3751,13 +3873,11 @@ int mgs_setparam(const struct lu_env *env, struct mgs_device *mgs,
 	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);
 
@@ -3849,6 +3969,83 @@ out:
         return rc;
 }
 
+int mgs_nodemap_cmd(const struct lu_env *env, struct mgs_device *mgs,
+		    enum lcfg_command_type cmd, const char *nodemap_name,
+		    const 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)