Whamcloud - gitweb
LU-8851 nodemap: add uid/gid only flags to control mapping
[fs/lustre-release.git] / lustre / mgs / mgs_handler.c
index 316d963..8c398a2 100644 (file)
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -27,7 +23,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2010, 2015, Intel Corporation.
+ * Copyright (c) 2010, 2016, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -47,6 +43,7 @@
 #include <lprocfs_status.h>
 #include <lustre_ioctl.h>
 #include <lustre_param.h>
+#include <lustre/lustre_barrier_user.h>
 
 #include "mgs_internal.h"
 
@@ -99,6 +96,7 @@ static inline bool str_starts_with(const char *str, const char *prefix)
        return strncmp(str, prefix, strlen(prefix)) == 0;
 }
 
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
 static int mgs_set_info(struct tgt_session_info *tsi)
 {
        struct mgs_thread_info  *mgi;
@@ -156,11 +154,13 @@ out_cfg:
        lustre_cfg_free(lcfg);
        return rc;
 }
+#endif
 
 enum ast_type {
-               AST_CONFIG = 1,
-               AST_PARAMS = 2,
-               AST_IR = 3
+       AST_CONFIG      = 1,
+       AST_PARAMS      = 2,
+       AST_IR          = 3,
+       AST_BARRIER     = 4,
 };
 
 static int mgs_completion_ast_generic(struct ldlm_lock *lock, __u64 flags,
@@ -194,6 +194,8 @@ static int mgs_completion_ast_generic(struct ldlm_lock *lock, __u64 flags,
                                case AST_IR:
                                        mgs_ir_notify_complete(fsdb);
                                        break;
+                               case AST_BARRIER:
+                                       break;
                                default:
                                        LBUG();
                        }
@@ -224,10 +226,18 @@ static int mgs_completion_ast_ir(struct ldlm_lock *lock, __u64 flags,
        return mgs_completion_ast_generic(lock, flags, cbdata, AST_IR);
 }
 
+static int mgs_completion_ast_barrier(struct ldlm_lock *lock, __u64 flags,
+                                     void *cbdata)
+{
+       return mgs_completion_ast_generic(lock, flags, cbdata, AST_BARRIER);
+}
+
 void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
 {
        ldlm_completion_callback cp = NULL;
-       struct lustre_handle     lockh = { 0 };
+       struct lustre_handle     lockh = {
+               .cookie = 0,
+       };
        struct ldlm_res_id       res_id;
        __u64 flags = LDLM_FL_ATOMIC_CB;
        int rc;
@@ -238,6 +248,7 @@ void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
        LASSERT(rc == 0);
        switch (type) {
        case CONFIG_T_CONFIG:
+       case CONFIG_T_NODEMAP:
                cp = mgs_completion_ast_config;
                if (test_and_set_bit(FSDB_REVOKING_LOCK, &fsdb->fsdb_flags))
                        rc = -EALREADY;
@@ -249,6 +260,10 @@ void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
                break;
        case CONFIG_T_RECOVER:
                cp = mgs_completion_ast_ir;
+               break;
+       case CONFIG_T_BARRIER:
+               cp = mgs_completion_ast_barrier;
+               break;
        default:
                break;
        }
@@ -261,7 +276,8 @@ void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
                                            NULL, fsdb, 0, LVB_T_NONE, NULL,
                                            &lockh);
                if (rc != ELDLM_OK) {
-                       CERROR("can't take cfg lock for "LPX64"/"LPX64"(%d)\n",
+                       CERROR("%s: can't take cfg lock for %#llx/%#llx : rc = %d\n",
+                              mgs->mgs_obd->obd_name,
                               le64_to_cpu(res_id.name[0]),
                               le64_to_cpu(res_id.name[1]), rc);
 
@@ -303,10 +319,7 @@ static int mgs_check_target(const struct lu_env *env,
                 rc = 1;
         } else {
                 /* Index is correctly marked as used */
-
-                /* If the logs don't contain the mti_nids then add
-                   them as failover nids */
-               rc = mgs_check_failnid(env, mgs, mti);
+               rc = 0;
         }
 
         RETURN(rc);
@@ -339,12 +352,14 @@ static int mgs_check_failover_reg(struct mgs_target_info *mti)
 /* Called whenever a target starts up.  Flags indicate first connect, etc. */
 static int mgs_target_reg(struct tgt_session_info *tsi)
 {
-       struct obd_device       *obd = tsi->tsi_exp->exp_obd;
-       struct mgs_device       *mgs = exp2mgs_dev(tsi->tsi_exp);
-       struct mgs_target_info  *mti, *rep_mti;
-       struct fs_db            *fsdb;
-       int                      opc;
-       int                      rc = 0;
+       struct obd_device *obd = tsi->tsi_exp->exp_obd;
+       struct mgs_device *mgs = exp2mgs_dev(tsi->tsi_exp);
+       struct mgs_target_info *mti, *rep_mti;
+       struct fs_db *b_fsdb = NULL; /* barrier fsdb */
+       struct fs_db *c_fsdb = NULL; /* config fsdb */
+       char barrier_name[20];
+       int opc;
+       int rc = 0;
 
        ENTRY;
 
@@ -360,80 +375,140 @@ static int mgs_target_reg(struct tgt_session_info *tsi)
                RETURN(err_serious(-EFAULT));
        }
 
+       down_read(&mgs->mgs_barrier_rwsem);
+
        if (OCD_HAS_FLAG(&tgt_ses_req(tsi)->rq_export->exp_connect_data,
                         IMP_RECOV))
                opc = mti->mti_flags & LDD_F_OPC_MASK;
        else
                opc = LDD_F_OPC_REG;
 
-        if (opc == LDD_F_OPC_READY) {
-                CDEBUG(D_MGS, "fs: %s index: %d is ready to reconnect.\n",
-                       mti->mti_fsname, mti->mti_stripe_index);
+       if (opc == LDD_F_OPC_READY) {
+               CDEBUG(D_MGS, "fs: %s index: %d is ready to reconnect.\n",
+                       mti->mti_fsname, mti->mti_stripe_index);
                rc = mgs_ir_update(tsi->tsi_env, mgs, mti);
-                if (rc) {
-                        LASSERT(!(mti->mti_flags & LDD_F_IR_CAPABLE));
-                        CERROR("Update IR return with %d(ignore and IR "
-                               "disabled)\n", rc);
-                }
-                GOTO(out_nolock, rc);
-        }
+               if (rc) {
+                       LASSERT(!(mti->mti_flags & LDD_F_IR_CAPABLE));
+                       CERROR("%s: Update IR return failure: rc = %d\n",
+                              mti->mti_fsname, rc);
+               }
 
-        /* Do not support unregistering right now. */
-        if (opc != LDD_F_OPC_REG)
-                GOTO(out_nolock, rc = -EINVAL);
+               GOTO(out_norevoke, rc);
+       }
 
-        CDEBUG(D_MGS, "fs: %s index: %d is registered to MGS.\n",
-               mti->mti_fsname, mti->mti_stripe_index);
+       /* Do not support unregistering right now. */
+       if (opc != LDD_F_OPC_REG)
+               GOTO(out_norevoke, rc = -EINVAL);
 
-        if (mti->mti_flags & LDD_F_NEED_INDEX)
-                mti->mti_flags |= LDD_F_WRITECONF;
+       snprintf(barrier_name, sizeof(barrier_name) - 1, "%s-%s",
+                mti->mti_fsname, BARRIER_FILENAME);
+       rc = mgs_find_or_make_fsdb(tsi->tsi_env, mgs, barrier_name, &b_fsdb);
+       if (rc) {
+               CERROR("%s: Can't get db for %s: rc = %d\n",
+                      mti->mti_fsname, barrier_name, rc);
 
-        if (!(mti->mti_flags & (LDD_F_WRITECONF | LDD_F_UPGRADE14 |
-                                LDD_F_UPDATE))) {
-                /* We're just here as a startup ping. */
-                CDEBUG(D_MGS, "Server %s is running on %s\n",
+               GOTO(out_norevoke, rc);
+       }
+
+       CDEBUG(D_MGS, "fs: %s index: %d is registered to MGS.\n",
+              mti->mti_fsname, mti->mti_stripe_index);
+
+       if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
+               if (b_fsdb->fsdb_barrier_status == BS_FREEZING_P1 ||
+                   b_fsdb->fsdb_barrier_status == BS_FREEZING_P2 ||
+                   b_fsdb->fsdb_barrier_status == BS_FROZEN) {
+                       LCONSOLE_WARN("%s: the system is in barrier, refuse "
+                                     "the connection from MDT %s temporary\n",
+                                     obd->obd_name, mti->mti_svname);
+
+                       GOTO(out_norevoke, rc = -EBUSY);
+               }
+
+               if (!(exp_connect_flags(tsi->tsi_exp) & OBD_CONNECT_BARRIER) &&
+                   !b_fsdb->fsdb_barrier_disabled) {
+                       LCONSOLE_WARN("%s: the MDT %s does not support write "
+                                     "barrier, so disable barrier on the "
+                                     "whole system.\n",
+                                     obd->obd_name, mti->mti_svname);
+
+                       b_fsdb->fsdb_barrier_disabled = 1;
+               }
+       }
+
+       if (mti->mti_flags & LDD_F_NEED_INDEX)
+               mti->mti_flags |= LDD_F_WRITECONF;
+
+       if (!(mti->mti_flags & (LDD_F_WRITECONF | LDD_F_UPGRADE14 |
+                               LDD_F_UPDATE))) {
+               /* We're just here as a startup ping. */
+               CDEBUG(D_MGS, "Server %s is running on %s\n",
                       mti->mti_svname, obd_export_nid2str(tsi->tsi_exp));
                rc = mgs_check_target(tsi->tsi_env, mgs, mti);
-                /* above will set appropriate mti flags */
-                if (rc <= 0)
-                        /* Nothing wrong, or fatal error */
-                        GOTO(out_nolock, rc);
+               /* above will set appropriate mti flags */
+               if (rc <= 0)
+                       /* Nothing wrong, or fatal error */
+                       GOTO(out_norevoke, rc);
        } else if (!(mti->mti_flags & LDD_F_NO_PRIMNODE)) {
                rc = mgs_check_failover_reg(mti);
                if (rc)
-                       GOTO(out_nolock, rc);
-        }
+                       GOTO(out_norevoke, rc);
+       }
 
-        OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_PAUSE_TARGET_REG, 10);
+       OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_PAUSE_TARGET_REG, 10);
 
-        if (mti->mti_flags & LDD_F_WRITECONF) {
-                if (mti->mti_flags & LDD_F_SV_TYPE_MDT &&
-                    mti->mti_stripe_index == 0) {
+       if (mti->mti_flags & LDD_F_WRITECONF) {
+               if (mti->mti_flags & LDD_F_SV_TYPE_MDT &&
+                   mti->mti_stripe_index == 0) {
+                       mgs_put_fsdb(mgs, b_fsdb);
+                       b_fsdb = NULL;
                        rc = mgs_erase_logs(tsi->tsi_env, mgs,
                                            mti->mti_fsname);
-                        LCONSOLE_WARN("%s: Logs for fs %s were removed by user "
-                                      "request.  All servers must be restarted "
-                                      "in order to regenerate the logs."
-                                      "\n", obd->obd_name, mti->mti_fsname);
-                } else if (mti->mti_flags &
-                           (LDD_F_SV_TYPE_OST | LDD_F_SV_TYPE_MDT)) {
+                       LCONSOLE_WARN("%s: Logs for fs %s were removed by user "
+                                     "request.  All servers must be restarted "
+                                     "in order to regenerate the logs: rc = %d"
+                                     "\n", obd->obd_name, mti->mti_fsname, rc);
+                       if (rc && rc != -ENOENT)
+                               GOTO(out_norevoke, rc);
+
+                       rc = mgs_find_or_make_fsdb(tsi->tsi_env, mgs,
+                                                  barrier_name, &b_fsdb);
+                       if (rc) {
+                               CERROR("Can't get db for %s: %d\n",
+                                      barrier_name, rc);
+
+                               GOTO(out_norevoke, rc);
+                       }
+
+                       if (!(exp_connect_flags(tsi->tsi_exp) &
+                             OBD_CONNECT_BARRIER)) {
+                               LCONSOLE_WARN("%s: the MDT %s does not support "
+                                             "write barrier, disable barrier "
+                                             "on the whole system.\n",
+                                             obd->obd_name, mti->mti_svname);
+
+                               b_fsdb->fsdb_barrier_disabled = 1;
+                       }
+               } else if (mti->mti_flags &
+                          (LDD_F_SV_TYPE_OST | LDD_F_SV_TYPE_MDT)) {
                        rc = mgs_erase_log(tsi->tsi_env, mgs, mti->mti_svname);
-                        LCONSOLE_WARN("%s: Regenerating %s log by user "
-                                      "request.\n",
-                                      obd->obd_name, mti->mti_svname);
-                }
-                mti->mti_flags |= LDD_F_UPDATE;
-                /* Erased logs means start from scratch. */
-                mti->mti_flags &= ~LDD_F_UPGRADE14;
-               if (rc)
-                       GOTO(out_nolock, rc);
-        }
+                       LCONSOLE_WARN("%s: Regenerating %s log by user "
+                                     "request: rc = %d\n",
+                                     obd->obd_name, mti->mti_svname, rc);
+                       if (rc)
+                               GOTO(out_norevoke, rc);
+               }
 
-       rc = mgs_find_or_make_fsdb(tsi->tsi_env, mgs, mti->mti_fsname, &fsdb);
-        if (rc) {
-                CERROR("Can't get db for %s: %d\n", mti->mti_fsname, rc);
-                GOTO(out_nolock, rc);
-        }
+               mti->mti_flags |= LDD_F_UPDATE;
+               /* Erased logs means start from scratch. */
+               mti->mti_flags &= ~LDD_F_UPGRADE14;
+       }
+
+       rc = mgs_find_or_make_fsdb(tsi->tsi_env, mgs, mti->mti_fsname, &c_fsdb);
+       if (rc) {
+               CERROR("Can't get db for %s: %d\n", mti->mti_fsname, rc);
+
+               GOTO(out_norevoke, rc);
+       }
 
         /*
          * Log writing contention is handled by the fsdb_mutex.
@@ -454,7 +529,7 @@ static int mgs_target_reg(struct tgt_session_info *tsi)
 
                 /* create or update the target log
                    and update the client/mdt logs */
-               rc = mgs_write_log_target(tsi->tsi_env, mgs, mti, fsdb);
+               rc = mgs_write_log_target(tsi->tsi_env, mgs, mti, c_fsdb);
                 if (rc) {
                         CERROR("Failed to write %s log (%d)\n",
                                mti->mti_svname, rc);
@@ -468,9 +543,27 @@ static int mgs_target_reg(struct tgt_session_info *tsi)
         }
 
 out:
-       mgs_revoke_lock(mgs, fsdb, CONFIG_T_CONFIG);
+       mgs_revoke_lock(mgs, c_fsdb, CONFIG_T_CONFIG);
+
+out_norevoke:
+       if (!rc && mti->mti_flags & LDD_F_SV_TYPE_MDT && b_fsdb) {
+               if (!c_fsdb) {
+                       rc = mgs_find_or_make_fsdb(tsi->tsi_env, mgs,
+                                                  mti->mti_fsname, &c_fsdb);
+                       if (rc)
+                               CERROR("Fail to get db for %s: %d\n",
+                                      mti->mti_fsname, rc);
+               }
+
+               if (c_fsdb) {
+                       memcpy(b_fsdb->fsdb_mdt_index_map,
+                              c_fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
+                       b_fsdb->fsdb_mdt_count = c_fsdb->fsdb_mdt_count;
+               }
+       }
+
+       up_read(&mgs->mgs_barrier_rwsem);
 
-out_nolock:
        CDEBUG(D_MGS, "replying with %s, index=%d, rc=%d\n", mti->mti_svname,
               mti->mti_stripe_index, rc);
         /* An error flag is set in the mti reply rather than an error code */
@@ -483,6 +576,10 @@ out_nolock:
 
        /* Flush logs to disk */
        dt_sync(tsi->tsi_env, mgs->mgs_bottom);
+       if (b_fsdb)
+               mgs_put_fsdb(mgs, b_fsdb);
+       if (c_fsdb)
+               mgs_put_fsdb(mgs, c_fsdb);
        RETURN(rc);
 }
 
@@ -514,6 +611,9 @@ static int mgs_config_read(struct tgt_session_info *tsi)
        case CONFIG_T_RECOVER:
                rc = mgs_get_ir_logs(req);
                break;
+       case CONFIG_T_NODEMAP:
+               rc = nodemap_get_config_req(req->rq_export->exp_obd, req);
+               break;
        case CONFIG_T_CONFIG:
                rc = -EOPNOTSUPP;
                break;
@@ -561,7 +661,7 @@ static int mgs_llog_open(struct tgt_session_info *tsi)
 
        logname = req_capsule_client_get(tsi->tsi_pill, &RMF_NAME);
        if (logname) {
-               char *ptr = strchr(logname, '-');
+               char *ptr = strrchr(logname, '-');
                int   len = (ptr != NULL) ? (int)(ptr - logname) : 0;
 
                if (ptr == NULL || len >= sizeof(mgi->mgi_fsname)) {
@@ -652,6 +752,7 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
                                 struct obd_ioctl_data *data)
 {
        struct lustre_cfg       *lcfg = NULL;
+       struct fs_db            *fsdb;
        lnet_nid_t              nid;
        const char              *nodemap_name = NULL;
        const char              *nidstr = NULL;
@@ -674,7 +775,7 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
                GOTO(out, rc = -EINVAL);
        }
 
-       if (data->ioc_plen1 > PAGE_CACHE_SIZE)
+       if (data->ioc_plen1 > PAGE_SIZE)
                GOTO(out, rc = -E2BIG);
 
        OBD_ALLOC(lcfg, data->ioc_plen1);
@@ -731,7 +832,9 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
                if (rc != 0)
                        GOTO(out_lcfg, rc = -EINVAL);
 
-               fs_id = nodemap_test_id(nid, idtype, client_id);
+               rc = nodemap_test_id(nid, idtype, client_id, &fs_id);
+               if (rc < 0)
+                       GOTO(out_lcfg, rc = -EINVAL);
 
                if (data->ioc_plen1 < sizeof(fs_idstr))
                        GOTO(out_lcfg, rc = -EINVAL);
@@ -747,6 +850,7 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
        case LCFG_NODEMAP_DEL_UIDMAP:
        case LCFG_NODEMAP_ADD_GIDMAP:
        case LCFG_NODEMAP_DEL_GIDMAP:
+       case LCFG_NODEMAP_SET_FILESET:
                if (lcfg->lcfg_bufcount != 3)
                        GOTO(out_lcfg, rc = -EINVAL);
                nodemap_name = lustre_cfg_string(lcfg, 1);
@@ -755,8 +859,10 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
                break;
        case LCFG_NODEMAP_ADMIN:
        case LCFG_NODEMAP_TRUSTED:
+       case LCFG_NODEMAP_DENY_UNKNOWN:
        case LCFG_NODEMAP_SQUASH_UID:
        case LCFG_NODEMAP_SQUASH_GID:
+       case LCFG_NODEMAP_MAP_MODE:
                if (lcfg->lcfg_bufcount != 4)
                        GOTO(out_lcfg, rc = -EINVAL);
                nodemap_name = lustre_cfg_string(lcfg, 1);
@@ -774,6 +880,16 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
                GOTO(out_lcfg, rc);
        }
 
+       /* revoke nodemap lock */
+       rc = mgs_find_or_make_fsdb(env, mgs, LUSTRE_NODEMAP_NAME, &fsdb);
+       if (rc < 0) {
+               CWARN("%s: cannot make nodemap fsdb: rc = %d\n",
+                     mgs->mgs_obd->obd_name, rc);
+       } else {
+               mgs_revoke_lock(mgs, fsdb, CONFIG_T_NODEMAP);
+               mgs_put_fsdb(mgs, fsdb);
+       }
+
 out_lcfg:
        OBD_FREE(lcfg, data->ioc_plen1);
 out:
@@ -800,7 +916,7 @@ static int mgs_iocontrol_pool(const struct lu_env *env,
                GOTO(out_pool, rc = -EINVAL);
         }
 
-       if (data->ioc_plen1 > PAGE_CACHE_SIZE)
+       if (data->ioc_plen1 > PAGE_SIZE)
                GOTO(out_pool, rc = -E2BIG);
 
         OBD_ALLOC(lcfg, data->ioc_plen1);
@@ -863,7 +979,7 @@ out_pool:
 
 /* from mdt_iocontrol */
 static int mgs_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
-                        void *karg, void *uarg)
+                        void *karg, void __user *uarg)
 {
        struct mgs_device *mgs = exp2mgs_dev(exp);
         struct obd_ioctl_data *data = karg;
@@ -952,10 +1068,23 @@ out_free:
                rc = mgs_iocontrol_pool(&env, mgs, data);
                break;
 
+       case OBD_IOC_BARRIER:
+               rc = mgs_iocontrol_barrier(&env, mgs, data);
+               break;
+
        case OBD_IOC_NODEMAP:
                rc = mgs_iocontrol_nodemap(&env, mgs, data);
                break;
 
+       case OBD_IOC_LCFG_FORK:
+               rc = mgs_lcfg_fork(&env, mgs, data->ioc_inlbuf1,
+                                  data->ioc_inlbuf2);
+               break;
+
+       case OBD_IOC_LCFG_ERASE:
+               rc = mgs_lcfg_erase(&env, mgs, data->ioc_inlbuf1);
+               break;
+
        case OBD_IOC_CATLOGLIST:
                rc = mgs_list_logs(&env, mgs, data);
                break;
@@ -1025,7 +1154,9 @@ TGT_RPC_HANDLER(MGS_FIRST_OPC,
                0,                      MGS_DISCONNECT,  mgs_disconnect,
                &RQF_MDS_DISCONNECT, LUSTRE_OBD_VERSION),
 TGT_MGS_HDL_VAR(0,                     MGS_EXCEPTION,   mgs_exception),
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
 TGT_MGS_HDL    (HABEO_REFERO | MUTABOR,        MGS_SET_INFO,    mgs_set_info),
+#endif
 TGT_MGS_HDL    (HABEO_REFERO | MUTABOR,        MGS_TARGET_REG,  mgs_target_reg),
 TGT_MGS_HDL_VAR(0,                     MGS_TARGET_DEL,  mgs_target_del),
 TGT_MGS_HDL    (HABEO_REFERO,          MGS_CONFIG_READ, mgs_config_read),
@@ -1098,8 +1229,6 @@ static int mgs_init0(const struct lu_env *env, struct mgs_device *mgs,
        struct obd_device               *obd;
        struct lustre_mount_info        *lmi;
        struct llog_ctxt                *ctxt;
-       struct fs_db                    *fsdb = NULL;
-       struct fs_db                    *fsdb_srpc = NULL;
        int                              rc;
 
        ENTRY;
@@ -1164,6 +1293,11 @@ static int mgs_init0(const struct lu_env *env, struct mgs_device *mgs,
        mgs->mgs_start_time = cfs_time_current_sec();
        spin_lock_init(&mgs->mgs_lock);
        mutex_init(&mgs->mgs_health_mutex);
+       init_rwsem(&mgs->mgs_barrier_rwsem);
+
+       rc = mgs_lcfg_rename(env, mgs);
+       if (rc)
+               GOTO(err_llog, rc);
 
        rc = lproc_mgs_setup(mgs, lustre_cfg_string(lcfg, 3));
        if (rc != 0) {
@@ -1174,14 +1308,14 @@ static int mgs_init0(const struct lu_env *env, struct mgs_device *mgs,
 
        /* Setup params fsdb and log, so that other servers can make a local
         * copy successfully when they are mounted. See LU-4783 */
-       rc = mgs_params_fsdb_setup(env, mgs, fsdb);
+       rc = mgs_params_fsdb_setup(env, mgs);
        if (rc)
                /* params fsdb and log can be setup later */
                CERROR("%s: %s fsdb and log setup failed: rc = %d\n",
                       obd->obd_name, PARAMS_FILENAME, rc);
 
        /* Setup _mgs fsdb, useful for srpc */
-       mgs__mgs_fsdb_setup(env, mgs, fsdb_srpc);
+       mgs__mgs_fsdb_setup(env, mgs);
 
        ptlrpc_init_client(LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL,
                           "mgs_ldlm_client", &obd->obd_ldlm_client);
@@ -1296,7 +1430,7 @@ static int mgs_object_init(const struct lu_env *env, struct lu_object *o,
        else
                rc = -ENOMEM;
 
-       return 0;
+       return rc;
 }
 
 static void mgs_object_free(const struct lu_env *env, struct lu_object *o)
@@ -1465,7 +1599,9 @@ static int mgs_obd_connect(const struct lu_env *env, struct obd_export **exp,
                           struct obd_connect_data *data, void *localdata)
 {
        struct obd_export       *lexp;
-       struct lustre_handle     conn = { 0 };
+       struct lustre_handle     conn = {
+               .cookie = 0,
+       };
        int                      rc;
 
        ENTRY;
@@ -1483,6 +1619,10 @@ static int mgs_obd_connect(const struct lu_env *env, struct obd_export **exp,
 
        if (data != NULL) {
                data->ocd_connect_flags &= MGS_CONNECT_SUPPORTED;
+
+               if (data->ocd_connect_flags & OBD_CONNECT_FLAGS2)
+                       data->ocd_connect_flags2 &= MGS_CONNECT_SUPPORTED2;
+
                data->ocd_version = LUSTRE_VERSION_CODE;
                lexp->exp_connect_data = *data;
        }
@@ -1511,6 +1651,10 @@ static int mgs_obd_reconnect(const struct lu_env *env, struct obd_export *exp,
 
        if (data != NULL) {
                data->ocd_connect_flags &= MGS_CONNECT_SUPPORTED;
+
+               if (data->ocd_connect_flags & OBD_CONNECT_FLAGS2)
+                       data->ocd_connect_flags2 &= MGS_CONNECT_SUPPORTED2;
+
                data->ocd_version = LUSTRE_VERSION_CODE;
                exp->exp_connect_data = *data;
        }