X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Fobd_mount_server.c;h=42af49002d912aad00d3fe6201a679e51185ae8a;hp=0cefea28f4bbac55024dd803ba1186120858cc82;hb=d5be104cc9b0c7a71b30aa5feb16873aa30803a9;hpb=b7f1952882e9e133b43acb22d010767c664539b9 diff --git a/lustre/obdclass/obd_mount_server.c b/lustre/obdclass/obd_mount_server.c index 0cefea2..42af490 100644 --- a/lustre/obdclass/obd_mount_server.c +++ b/lustre/obdclass/obd_mount_server.c @@ -15,11 +15,7 @@ * * 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) 2013, Intel Corporation. + * Copyright (c) 2013, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -46,35 +42,36 @@ #define PRINT_CMD CDEBUG #define PRINT_MASK (D_SUPER | D_CONFIG) -#include -#include -#include +#include +#include +#include #include -#include -#include -#include -#include #ifdef HAVE_KERNEL_LOCKED #include #endif -#ifdef HAVE_SELINUX_IS_ENABLED -#include -#endif + +#include +#include +#include +#include +#include +#include +#include /*********** mount lookup *********/ -DEFINE_MUTEX(lustre_mount_info_lock); -static CFS_LIST_HEAD(server_mount_info_list); +static DEFINE_MUTEX(lustre_mount_info_lock); +static LIST_HEAD(server_mount_info_list); static struct lustre_mount_info *server_find_mount(const char *name) { - cfs_list_t *tmp; + struct list_head *tmp; struct lustre_mount_info *lmi; ENTRY; - cfs_list_for_each(tmp, &server_mount_info_list) { - lmi = cfs_list_entry(tmp, struct lustre_mount_info, - lmi_list_chain); + list_for_each(tmp, &server_mount_info_list) { + lmi = list_entry(tmp, struct lustre_mount_info, + lmi_list_chain); if (strcmp(name, lmi->lmi_name) == 0) RETURN(lmi); } @@ -113,7 +110,7 @@ static int server_register_mount(const char *name, struct super_block *sb) } lmi->lmi_name = name_cp; lmi->lmi_sb = sb; - cfs_list_add(&lmi->lmi_list_chain, &server_mount_info_list); + list_add(&lmi->lmi_list_chain, &server_mount_info_list); mutex_unlock(&lustre_mount_info_lock); @@ -139,7 +136,7 @@ static int server_deregister_mount(const char *name) CDEBUG(D_MOUNT, "deregister mount %p from %s\n", lmi->lmi_sb, name); OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1); - cfs_list_del(&lmi->lmi_list_chain); + list_del(&lmi->lmi_list_chain); OBD_FREE(lmi, sizeof(*lmi)); mutex_unlock(&lustre_mount_info_lock); @@ -239,8 +236,8 @@ static int server_start_mgs(struct super_block *sb) if (!rc) { rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME, - LUSTRE_MGS_OBDNAME, 0, 0, - lsi->lsi_osd_obdname, 0); + LUSTRE_MGS_OBDNAME, NULL, NULL, + lsi->lsi_osd_obdname, NULL); /* server_deregister_mount() is not called previously, for lsi * and other stuff can't be freed cleanly when mgs calls * server_put_mount() in error handling case (see b=17758), @@ -262,8 +259,14 @@ static int server_stop_mgs(struct super_block *sb) { struct obd_device *obd; int rc; + struct lustre_mount_info *lmi; ENTRY; + /* Do not stop MGS if this device is not the running MGT */ + lmi = server_find_mount(LUSTRE_MGS_OBDNAME); + if (lmi != NULL && lmi->lmi_sb != sb) + RETURN(0); + CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME); /* There better be only one MGS */ @@ -281,7 +284,8 @@ static int server_stop_mgs(struct super_block *sb) /* Since there's only one mgc per node, we have to change it's fs to get access to the right disk. */ -static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb) +static int server_mgc_set_fs(const struct lu_env *env, + struct obd_device *mgc, struct super_block *sb) { struct lustre_sb_info *lsi = s2lsi(sb); int rc; @@ -290,7 +294,7 @@ static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb) CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev); /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */ - rc = obd_set_info_async(NULL, mgc->obd_self_export, + rc = obd_set_info_async(env, mgc->obd_self_export, sizeof(KEY_SET_FS), KEY_SET_FS, sizeof(*sb), sb, NULL); if (rc != 0) @@ -299,14 +303,15 @@ static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb) RETURN(rc); } -static int server_mgc_clear_fs(struct obd_device *mgc) +static int server_mgc_clear_fs(const struct lu_env *env, + struct obd_device *mgc) { int rc; ENTRY; CDEBUG(D_MOUNT, "Unassign mgc disk\n"); - rc = obd_set_info_async(NULL, mgc->obd_self_export, + rc = obd_set_info_async(env, mgc->obd_self_export, sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS, 0, NULL, NULL); RETURN(rc); @@ -374,14 +379,26 @@ cleanup: } EXPORT_SYMBOL(tgt_name2lwp_name); -static CFS_LIST_HEAD(lwp_register_list); -DEFINE_MUTEX(lwp_register_list_lock); +static LIST_HEAD(lwp_register_list); +static DEFINE_SPINLOCK(lwp_register_list_lock); + +static void lustre_put_lwp_item(struct lwp_register_item *lri) +{ + if (atomic_dec_and_test(&lri->lri_ref)) { + LASSERT(list_empty(&lri->lri_list)); + + if (*lri->lri_exp != NULL) + class_export_put(*lri->lri_exp); + OBD_FREE_PTR(lri); + } +} int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp, register_lwp_cb cb_func, void *cb_data) { struct obd_device *lwp; struct lwp_register_item *lri; + bool cb = false; ENTRY; LASSERTF(strlen(lwpname) < MTI_NAME_MAXLEN, "lwpname is too long %s\n", @@ -392,15 +409,12 @@ int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp, if (lri == NULL) RETURN(-ENOMEM); - mutex_lock(&lwp_register_list_lock); - lwp = class_name2obd(lwpname); if (lwp != NULL && lwp->obd_set_up == 1) { struct obd_uuid *uuid; OBD_ALLOC_PTR(uuid); if (uuid == NULL) { - mutex_unlock(&lwp_register_list_lock); OBD_FREE_PTR(lri); RETURN(-ENOMEM); } @@ -413,32 +427,59 @@ int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp, lri->lri_exp = exp; lri->lri_cb_func = cb_func; lri->lri_cb_data = cb_data; - CFS_INIT_LIST_HEAD(&lri->lri_list); - cfs_list_add(&lri->lri_list, &lwp_register_list); + INIT_LIST_HEAD(&lri->lri_list); + /* + * Initialize the lri_ref at 2, one will be released before + * current function returned via lustre_put_lwp_item(), the + * other will be released in lustre_deregister_lwp_item(). + */ + atomic_set(&lri->lri_ref, 2); + + spin_lock(&lwp_register_list_lock); + list_add(&lri->lri_list, &lwp_register_list); + if (*exp != NULL) + cb = true; + spin_unlock(&lwp_register_list_lock); - if (*exp != NULL && cb_func != NULL) + if (cb && cb_func != NULL) cb_func(cb_data); + lustre_put_lwp_item(lri); - mutex_unlock(&lwp_register_list_lock); RETURN(0); } EXPORT_SYMBOL(lustre_register_lwp_item); void lustre_deregister_lwp_item(struct obd_export **exp) { - struct lwp_register_item *lri, *tmp; + struct lwp_register_item *lri; + bool removed = false; + int repeat = 0; - mutex_lock(&lwp_register_list_lock); - cfs_list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) { + spin_lock(&lwp_register_list_lock); + list_for_each_entry(lri, &lwp_register_list, lri_list) { if (exp == lri->lri_exp) { - if (*exp) - class_export_put(*exp); - cfs_list_del(&lri->lri_list); - OBD_FREE_PTR(lri); + list_del_init(&lri->lri_list); + removed = true; break; } } - mutex_unlock(&lwp_register_list_lock); + spin_unlock(&lwp_register_list_lock); + + if (!removed) + return; + + /* See lustre_notify_lwp_list(), in some extreme race conditions, + * the notify callback could be still on the fly, we need to wait + * for the callback done before moving on to free the data used + * by callback. */ + while (atomic_read(&lri->lri_ref) > 1) { + CDEBUG(D_MOUNT, "lri reference count %u, repeat: %d\n", + atomic_read(&lri->lri_ref), repeat); + repeat++; + set_current_state(TASK_INTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1)); + } + lustre_put_lwp_item(lri); } EXPORT_SYMBOL(lustre_deregister_lwp_item); @@ -469,7 +510,7 @@ struct obd_export *lustre_find_lwp_by_index(const char *dev, __u32 idx) list_for_each_entry(lwp, &lsi->lsi_lwp_list, obd_lwp_list) { char *ptr = strstr(lwp->obd_name, lwp_name); - if (ptr != NULL) { + if (ptr != NULL && lwp->obd_lwp_export != NULL) { exp = class_export_get(lwp->obd_lwp_export); break; } @@ -483,25 +524,39 @@ err_lmi: } EXPORT_SYMBOL(lustre_find_lwp_by_index); -static void lustre_notify_lwp_list(struct obd_export *exp) +void lustre_notify_lwp_list(struct obd_export *exp) { - struct lwp_register_item *lri, *tmp; + struct lwp_register_item *lri; LASSERT(exp != NULL); - mutex_lock(&lwp_register_list_lock); - cfs_list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) { +again: + spin_lock(&lwp_register_list_lock); + list_for_each_entry(lri, &lwp_register_list, lri_list) { if (strcmp(exp->exp_obd->obd_name, lri->lri_name)) continue; if (*lri->lri_exp != NULL) continue; *lri->lri_exp = class_export_get(exp); - if (lri->lri_cb_func != NULL) - lri->lri_cb_func(lri->lri_cb_data); + if (lri->lri_cb_func == NULL) + continue; + atomic_inc(&lri->lri_ref); + spin_unlock(&lwp_register_list_lock); + + lri->lri_cb_func(lri->lri_cb_data); + lustre_put_lwp_item(lri); + + /* Others may have changed the list after we unlock, we have + * to rescan the list from the beginning. Usually, the list + * 'lwp_register_list' is very short, and there is 'guard' + * lri::lri_exp that will prevent the callback to be done + * repeatedly. So rescanning the list has no problem. */ + goto again; } - mutex_unlock(&lwp_register_list_lock); + spin_unlock(&lwp_register_list_lock); } +EXPORT_SYMBOL(lustre_notify_lwp_list); -static int lustre_lwp_connect(struct obd_device *lwp) +static int lustre_lwp_connect(struct obd_device *lwp, bool is_mdt) { struct lu_env env; struct lu_context session_ctx; @@ -527,10 +582,14 @@ static int lustre_lwp_connect(struct obd_device *lwp) data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX; data->ocd_version = LUSTRE_VERSION_CODE; - data->ocd_connect_flags |= OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID | - OBD_CONNECT_AT | OBD_CONNECT_LRU_RESIZE | - OBD_CONNECT_FULL20 | OBD_CONNECT_LVB_TYPE | - OBD_CONNECT_LIGHTWEIGHT | OBD_CONNECT_LFSCK; + data->ocd_connect_flags |= OBD_CONNECT_FID | OBD_CONNECT_AT | + OBD_CONNECT_LRU_RESIZE | OBD_CONNECT_FULL20 | + OBD_CONNECT_LVB_TYPE | OBD_CONNECT_LIGHTWEIGHT | + OBD_CONNECT_LFSCK | OBD_CONNECT_BULK_MBITS; + + if (is_mdt) + data->ocd_connect_flags |= OBD_CONNECT_MDS_MDS; + OBD_ALLOC_PTR(uuid); if (uuid == NULL) GOTO(out, rc = -ENOMEM); @@ -550,7 +609,6 @@ static int lustre_lwp_connect(struct obd_device *lwp) if (unlikely(lwp->obd_lwp_export != NULL)) class_export_put(lwp->obd_lwp_export); lwp->obd_lwp_export = class_export_get(exp); - lustre_notify_lwp_list(exp); } GOTO(out, rc); @@ -606,7 +664,7 @@ static int lustre_lwp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi, sprintf(lwpuuid, "%s_UUID", lwpname); rc = lustre_start_simple(lwpname, LUSTRE_LWP_NAME, lwpuuid, lustre_cfg_string(lcfg, 1), - 0, 0, 0); + NULL, NULL, NULL); if (rc) { CERROR("%s: setup up failed: rc %d\n", lwpname, rc); GOTO(out, rc); @@ -615,7 +673,7 @@ static int lustre_lwp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi, obd = class_name2obd(lwpname); LASSERT(obd != NULL); - rc = lustre_lwp_connect(obd); + rc = lustre_lwp_connect(obd, strstr(lsi->lsi_svname, "-MDT") != NULL); if (rc == 0) { obd->u.cli.cl_max_mds_easize = MAX_MD_SIZE; spin_lock(&lsi->lsi_lwp_lock); @@ -697,15 +755,18 @@ static int lustre_lwp_add_conn(struct lustre_cfg *cfg, lustre_cfg_bufs_set_string(bufs, 1, lustre_cfg_string(cfg, 1)); - lcfg = lustre_cfg_new(LCFG_ADD_CONN, bufs); - if (lcfg == NULL) + OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount, bufs->lcfg_buflen)); + if (!lcfg) GOTO(out_cfg, rc = -ENOMEM); + lustre_cfg_init(lcfg, LCFG_ADD_CONN, bufs); + rc = class_add_conn(lwp, lcfg); if (rc) CERROR("%s: can't add conn: rc = %d\n", lwpname, rc); - if (lcfg != NULL) - lustre_cfg_free(lcfg); + if (lcfg) + OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, + lcfg->lcfg_buflens)); out_cfg: if (bufs != NULL) OBD_FREE_PTR(bufs); @@ -737,7 +798,7 @@ static int client_lwp_config_process(const struct lu_env *env, struct llog_handle *handle, struct llog_rec_hdr *rec, void *data) { - struct config_llog_instance *clli = data; + struct config_llog_instance *cfg = data; int cfg_len = rec->lrh_len; char *cfg_buf = (char *) (rec + 1); struct lustre_cfg *lcfg = NULL; @@ -751,8 +812,9 @@ static int client_lwp_config_process(const struct lu_env *env, RETURN(-EINVAL); } - LASSERT(clli->cfg_sb != NULL); - lsi = s2lsi(clli->cfg_sb); + if (cfg->cfg_sb == NULL) + GOTO(out, rc = -EINVAL); + lsi = s2lsi(cfg->cfg_sb); lcfg = (struct lustre_cfg *)cfg_buf; if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) { @@ -774,35 +836,35 @@ static int client_lwp_config_process(const struct lu_env *env, marker->cm_flags & CM_EXCLUDE) GOTO(out, rc = 0); - if (!tgt_is_mdt(marker->cm_tgtname, &clli->cfg_lwp_idx)) + if (!tgt_is_mdt(marker->cm_tgtname, &cfg->cfg_lwp_idx)) GOTO(out, rc = 0); - if (IS_MDT(lsi) && clli->cfg_lwp_idx != 0) + if (IS_MDT(lsi) && cfg->cfg_lwp_idx != 0) GOTO(out, rc = 0); if (!strncmp(marker->cm_comment, "add mdc", 7) || !strncmp(marker->cm_comment, "add failnid", 11)) { if (marker->cm_flags & CM_START) { - clli->cfg_flags = CFG_F_MARKER; + cfg->cfg_flags = CFG_F_MARKER; /* This hack is to differentiate the * ADD_UUID is come from "add mdc" record * or from "add failnid" record. */ if (!strncmp(marker->cm_comment, "add failnid", 11)) - clli->cfg_flags |= CFG_F_SKIP; + cfg->cfg_flags |= CFG_F_SKIP; } else if (marker->cm_flags & CM_END) { - clli->cfg_flags = 0; + cfg->cfg_flags = 0; } } break; } case LCFG_ADD_UUID: { - if (clli->cfg_flags == CFG_F_MARKER) { - rc = lustre_lwp_setup(lcfg, lsi, clli->cfg_lwp_idx); + if (cfg->cfg_flags == CFG_F_MARKER) { + rc = lustre_lwp_setup(lcfg, lsi, cfg->cfg_lwp_idx); /* XXX: process only the first nid as * we don't need another instance of lwp */ - clli->cfg_flags |= CFG_F_SKIP; - } else if (clli->cfg_flags == (CFG_F_MARKER | CFG_F_SKIP)) { + cfg->cfg_flags |= CFG_F_SKIP; + } else if (cfg->cfg_flags == (CFG_F_MARKER | CFG_F_SKIP)) { rc = class_add_uuid(lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid); if (rc) @@ -872,9 +934,9 @@ static int lustre_disconnect_lwp(struct super_block *sb) GOTO(out, rc = -ENOMEM); /* end log first */ - cfg->cfg_instance = sb; + cfg->cfg_instance = ll_get_cfg_instance(sb); rc = lustre_end_log(sb, logname, cfg); - if (rc != 0) + if (rc != 0 && rc != -ENOENT) GOTO(out, rc); lsi->lsi_lwp_started = 0; @@ -894,15 +956,18 @@ static int lustre_disconnect_lwp(struct super_block *sb) lustre_cfg_bufs_reset(bufs, lwp->obd_name); lustre_cfg_bufs_set_string(bufs, 1, NULL); - lcfg = lustre_cfg_new(LCFG_CLEANUP, bufs); - if (lcfg == NULL) + OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount, + bufs->lcfg_buflen)); + if (!lcfg) GOTO(out, rc = -ENOMEM); + lustre_cfg_init(lcfg, LCFG_CLEANUP, bufs); /* Disconnect import first. NULL is passed for the '@env', * since it will not be used. */ rc = lwp->obd_lu_dev->ld_ops->ldo_process_config(NULL, lwp->obd_lu_dev, lcfg); - lustre_cfg_free(lcfg); + OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, + lcfg->lcfg_buflens)); if (rc != 0 && rc != -ETIMEDOUT) { CERROR("%s: fail to disconnect LWP: rc = %d\n", lwp->obd_name, rc); @@ -981,10 +1046,10 @@ static int lustre_start_lwp(struct super_block *sb) GOTO(out, rc = -ENOMEM); cfg->cfg_callback = client_lwp_config_process; - cfg->cfg_instance = sb; + cfg->cfg_instance = ll_get_cfg_instance(sb); rc = lustre_process_log(sb, logname, cfg); - if (rc == 0) - lsi->lsi_lwp_started = 1; + /* need to remove config llog from mgc */ + lsi->lsi_lwp_started = 1; GOTO(out, rc); @@ -996,7 +1061,7 @@ out: return rc; } -DEFINE_MUTEX(server_start_lock); +static DEFINE_MUTEX(server_start_lock); /* Stop MDS/OSS if nobody is using them */ static int server_stop_servers(int lsiflags) @@ -1044,13 +1109,12 @@ int server_mti_print(const char *title, struct mgs_target_info *mti) mti->mti_config_ver, mti->mti_flags); return 0; } -EXPORT_SYMBOL(server_mti_print); /* Generate data for registration */ static int server_lsi2mti(struct lustre_sb_info *lsi, struct mgs_target_info *mti) { - lnet_process_id_t id; + struct lnet_process_id id; int rc, i = 0; int cplen = 0; ENTRY; @@ -1088,6 +1152,13 @@ static int server_lsi2mti(struct lustre_sb_info *lsi, } } + if (mti->mti_nid_count == 0) { + CERROR("Failed to get NID for server %s, please check whether " + "the target is specifed with improper --servicenode or " + "--network options.\n", mti->mti_svname); + RETURN(-EINVAL); + } + mti->mti_lustre_ver = LUSTRE_VERSION_CODE; mti->mti_config_ver = 0; @@ -1119,6 +1190,7 @@ static int server_register_target(struct lustre_sb_info *lsi) struct mgs_target_info *mti = NULL; bool writeconf; int rc; + int tried = 0; ENTRY; LASSERT(mgc); @@ -1143,6 +1215,7 @@ static int server_register_target(struct lustre_sb_info *lsi) writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE)); mti->mti_flags |= LDD_F_OPC_REG; +again: /* Register the target */ /* FIXME use mgc_process_config instead */ rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp, @@ -1156,13 +1229,24 @@ static int server_register_target(struct lustre_sb_info *lsi) "to start: rc = %d. Please see messages on " "the MGS.\n", lsi->lsi_svname, rc); } else if (writeconf) { + if ((rc == -ESHUTDOWN || rc == -EIO) && ++tried < 5) { + /* The connection with MGS is not established. + * Try again after 2 seconds. Interruptable. */ + set_current_state(TASK_INTERRUPTIBLE); + schedule_timeout( + msecs_to_jiffies(MSEC_PER_SEC) * 2); + set_current_state(TASK_RUNNING); + if (!signal_pending(current)) + goto again; + } + LCONSOLE_ERROR_MSG(0x15f, "%s: cannot register this server with the MGS: " "rc = %d. Is the MGS running?\n", lsi->lsi_svname, rc); } else { - CERROR("%s: error registering with the MGS: rc = %d " - "(not fatal)\n", lsi->lsi_svname, rc); + CDEBUG(D_HA, "%s: error registering with the MGS: " + "rc = %d (not fatal)\n", lsi->lsi_svname, rc); /* reset the error code for non-fatal error. */ rc = 0; } @@ -1227,7 +1311,7 @@ static int server_start_targets(struct super_block *sb) struct obd_device *obd; struct lustre_sb_info *lsi = s2lsi(sb); struct config_llog_instance cfg; - struct lu_env env; + struct lu_env mgc_env; struct lu_device *dev; int rc; ENTRY; @@ -1242,7 +1326,7 @@ static int server_start_targets(struct super_block *sb) rc = lustre_start_simple(LUSTRE_MDS_OBDNAME, LUSTRE_MDS_NAME, LUSTRE_MDS_OBDNAME"_uuid", - 0, 0, 0, 0); + NULL, NULL, NULL, NULL); if (rc) { mutex_unlock(&server_start_lock); CERROR("failed to start MDS: %d\n", rc); @@ -1261,7 +1345,7 @@ static int server_start_targets(struct super_block *sb) rc = lustre_start_simple(LUSTRE_OSS_OBDNAME, LUSTRE_OSS_NAME, LUSTRE_OSS_OBDNAME"_uuid", - 0, 0, 0, 0); + NULL, NULL, NULL, NULL); if (rc) { mutex_unlock(&server_start_lock); CERROR("failed to start OSS: %d\n", rc); @@ -1271,11 +1355,15 @@ static int server_start_targets(struct super_block *sb) mutex_unlock(&server_start_lock); } + rc = lu_env_init(&mgc_env, LCT_MG_THREAD); + if (rc != 0) + GOTO(out_stop_service, rc); + /* Set the mgc fs to our server disk. This allows the MGC to * read and write configs locally, in case it can't talk to the MGS. */ - rc = server_mgc_set_fs(lsi->lsi_mgc, sb); + rc = server_mgc_set_fs(&mgc_env, lsi->lsi_mgc, sb); if (rc) - GOTO(out_stop_service, rc); + GOTO(out_env, rc); /* Register with MGS */ rc = server_register_target(lsi); @@ -1291,6 +1379,7 @@ static int server_start_targets(struct super_block *sb) /* Start targets using the llog named for the target */ memset(&cfg, 0, sizeof(cfg)); cfg.cfg_callback = class_config_llog_handler; + cfg.cfg_sub_clds = CONFIG_SUB_SERVER; rc = lustre_process_log(sb, lsi->lsi_svname, &cfg); if (rc) { CERROR("failed to start server %s: %d\n", @@ -1321,12 +1410,11 @@ static int server_start_targets(struct super_block *sb) /* calculate recovery timeout, do it after lustre_process_log */ server_calc_timeout(lsi, obd); - /* log has been fully processed */ - obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG); - /* log has been fully processed, let clients connect */ dev = obd->obd_lu_dev; if (dev && dev->ld_ops->ldo_prepare) { + struct lu_env env; + rc = lu_env_init(&env, dev->ld_type->ldt_ctx_tags); if (rc == 0) { struct lu_context session_ctx; @@ -1354,8 +1442,9 @@ static int server_start_targets(struct super_block *sb) out_mgc: /* Release the mgc fs for others to use */ - server_mgc_clear_fs(lsi->lsi_mgc); - + server_mgc_clear_fs(&mgc_env, lsi->lsi_mgc); +out_env: + lu_env_fini(&mgc_env); out_stop_service: if (rc != 0) server_stop_servers(lsi->lsi_flags); @@ -1365,6 +1454,8 @@ out_stop_service: static int lsi_prepare(struct lustre_sb_info *lsi) { + const char *osd_type; + const char *fstype; __u32 index; int rc; ENTRY; @@ -1378,28 +1469,26 @@ static int lsi_prepare(struct lustre_sb_info *lsi) RETURN(-EINVAL); } - if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname)) - RETURN(-ENAMETOOLONG); - - strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile); - /* Determine osd type */ - if (lsi->lsi_lmd->lmd_osd_type != NULL) { - if (strlen(lsi->lsi_lmd->lmd_osd_type) >= - sizeof(lsi->lsi_osd_type)) - RETURN(-ENAMETOOLONG); - - strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type); + if (lsi->lsi_lmd->lmd_osd_type == NULL) { + osd_type = LUSTRE_OSD_LDISKFS_NAME; + fstype = "ldiskfs"; } else { - strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME); + osd_type = lsi->lsi_lmd->lmd_osd_type; + fstype = lsi->lsi_lmd->lmd_osd_type; } + if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname) || + strlen(osd_type) >= sizeof(lsi->lsi_osd_type) || + strlen(fstype) >= sizeof(lsi->lsi_fstype)) + RETURN(-ENAMETOOLONG); + + strlcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile, + sizeof(lsi->lsi_svname)); + strlcpy(lsi->lsi_osd_type, osd_type, sizeof(lsi->lsi_osd_type)); /* XXX: a temp. solution for components using ldiskfs * to be removed in one of the subsequent patches */ - if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) - strcpy(lsi->lsi_fstype, "ldiskfs"); - else - strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type); + strlcpy(lsi->lsi_fstype, fstype, sizeof(lsi->lsi_fstype)); /* Determine server type */ rc = server_name2index(lsi->lsi_svname, &index, NULL); @@ -1478,9 +1567,13 @@ static void server_put_super(struct super_block *sb) If there are any setup/cleanup errors, save the lov name for safety cleanup later. */ lprof = class_get_profile(lsi->lsi_svname); - if (lprof && lprof->lp_dt) { - OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1); - strcpy(extraname, lprof->lp_dt); + if (lprof != NULL) { + if (lprof->lp_dt != NULL) { + OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1); + strncpy(extraname, lprof->lp_dt, + strlen(lprof->lp_dt) + 1); + } + class_put_profile(lprof); } obd = class_name2obd(lsi->lsi_svname); @@ -1584,6 +1677,63 @@ static int server_statfs(struct dentry *dentry, struct kstatfs *buf) RETURN(0); } +#ifdef HAVE_SUPEROPS_USE_DENTRY +int server_show_options(struct seq_file *seq, struct dentry *dentry) +#else +int server_show_options(struct seq_file *seq, struct vfsmount *vfs) +#endif +{ + struct lustre_sb_info *lsi; + struct lustre_mount_data *lmd; + +#ifdef HAVE_SUPEROPS_USE_DENTRY + LASSERT(seq != NULL && dentry != NULL); + lsi = s2lsi(dentry->d_sb); +#else + LASSERT(seq != NULL && vfs != NULL); + lsi = s2lsi(vfs->mnt_sb); +#endif + + lmd = lsi->lsi_lmd; + seq_printf(seq, ",svname=%s", lmd->lmd_profile); + + if (lmd->lmd_flags & LMD_FLG_ABORT_RECOV) + seq_puts(seq, ",abort_recov"); + + if (lmd->lmd_flags & LMD_FLG_NOIR) + seq_puts(seq, ",noir"); + + if (lmd->lmd_flags & LMD_FLG_NOSVC) + seq_puts(seq, ",nosvc"); + + if (lmd->lmd_flags & LMD_FLG_NOMGS) + seq_puts(seq, ",nomgs"); + + if (lmd->lmd_flags & LMD_FLG_NOSCRUB) + seq_puts(seq, ",noscrub"); + if (lmd->lmd_flags & LMD_FLG_SKIP_LFSCK) + seq_puts(seq, ",skip_lfsck"); + + if (lmd->lmd_flags & LMD_FLG_DEV_RDONLY) + seq_puts(seq, ",rdonly_dev"); + + if (lmd->lmd_flags & LMD_FLG_MGS) + seq_puts(seq, ",mgs"); + + if (lmd->lmd_mgs != NULL) + seq_printf(seq, ",mgsnode=%s", lmd->lmd_mgs); + + if (lmd->lmd_osd_type != NULL) + seq_printf(seq, ",osd=%s", lmd->lmd_osd_type); + + if (lmd->lmd_opts != NULL) { + seq_putc(seq, ','); + seq_puts(seq, lmd->lmd_opts); + } + + RETURN(0); +} + /** The operations we support directly on the superblock: * mount, umount, and df. */ @@ -1591,11 +1741,13 @@ static struct super_operations server_ops = { .put_super = server_put_super, .umount_begin = server_umount_begin, /* umount -f */ .statfs = server_statfs, + .show_options = server_show_options, }; /* * Xattr support for Lustre servers */ +#ifdef HAVE_IOP_XATTR static ssize_t lustre_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size) { @@ -1609,6 +1761,7 @@ static int lustre_setxattr(struct dentry *dentry, const char *name, { return -EOPNOTSUPP; } +#endif static ssize_t lustre_listxattr(struct dentry *d_entry, char *name, size_t size) @@ -1616,18 +1769,61 @@ static ssize_t lustre_listxattr(struct dentry *d_entry, char *name, return -EOPNOTSUPP; } -const struct inode_operations server_inode_operations = { +static bool is_cmd_supported(unsigned int command) +{ + switch (command) { + case FITRIM: + return true; + default: + return false; + } + + return false; +} + +static long server_ioctl(struct file *filp, unsigned int command, + unsigned long arg) +{ + struct file active_filp; + struct inode *inode = file_inode(filp); + struct lustre_sb_info *lsi = s2lsi(inode->i_sb); + struct super_block *dd_sb = dt_mnt_sb_get(lsi->lsi_dt_dev); + struct inode *active_inode; + int err = -EOPNOTSUPP; + + if (IS_ERR(dd_sb) || !is_cmd_supported(command)) + return err; + + active_inode = igrab(dd_sb->s_root->d_inode); + if (!active_inode) + return -EACCES; + + active_filp.f_inode = active_inode; + if (active_inode->i_fop && active_inode->i_fop->unlocked_ioctl) + err = active_inode->i_fop->unlocked_ioctl(&active_filp, + command, arg); + iput(active_inode); + return err; +} + +static const struct inode_operations server_inode_operations = { +#ifdef HAVE_IOP_XATTR .setxattr = lustre_setxattr, .getxattr = lustre_getxattr, +#endif .listxattr = lustre_listxattr, }; +static const struct file_operations server_file_operations = { + .unlocked_ioctl = server_ioctl, +}; + #define log2(n) ffz(~(n)) #define LUSTRE_SUPER_MAGIC 0x0BD00BD1 static int server_fill_super_common(struct super_block *sb) { - struct inode *root = 0; + struct inode *root = NULL; ENTRY; CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev); @@ -1650,6 +1846,7 @@ static int server_fill_super_common(struct super_block *sb) /* apparently we need to be a directory for the mount to finish */ root->i_mode = S_IFDIR; root->i_op = &server_inode_operations; + root->i_fop = &server_file_operations; sb->s_root = d_make_root(root); if (!sb->s_root) { CERROR("%s: can't make root dentry\n", sb->s_id); @@ -1662,10 +1859,10 @@ static int server_fill_super_common(struct super_block *sb) static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags) { struct lustre_mount_data *lmd = lsi->lsi_lmd; - struct obd_device *obd; - struct dt_device_param p; - char flagstr[16]; - int rc; + struct obd_device *obd; + struct dt_device_param p; + char flagstr[20 + 1 + 10 + 1]; + int rc; ENTRY; CDEBUG(D_MOUNT, @@ -1675,7 +1872,7 @@ static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags) sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname); strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname); strcat(lsi->lsi_osd_uuid, "_UUID"); - sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags); + snprintf(flagstr, sizeof(flagstr), "%lu:%u", mflags, lmd->lmd_flags); obd = class_name2obd(lsi->lsi_osd_obdname); if (obd == NULL) { @@ -1688,10 +1885,20 @@ static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags) GOTO(out, rc); obd = class_name2obd(lsi->lsi_osd_obdname); LASSERT(obd); + } else { + CDEBUG(D_MOUNT, "%s already started\n", lsi->lsi_osd_obdname); + /* but continue setup to allow special case of MDT and internal + * MGT being started separately. */ + if (!((IS_MGS(lsi) && (lsi->lsi_lmd->lmd_flags & + LMD_FLG_NOMGS)) || + (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & + LMD_FLG_NOSVC)))) + RETURN(-EALREADY); } rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL); + if (rc) { obd->obd_force = 1; class_manual_cleanup(obd); @@ -1724,9 +1931,14 @@ int server_fill_super(struct super_block *sb) int rc; ENTRY; + /* to simulate target mount race */ + OBD_RACE(OBD_FAIL_TGT_MOUNT_RACE); + rc = lsi_prepare(lsi); - if (rc) + if (rc) { + lustre_put_lsi(sb); RETURN(rc); + } /* Start low level OSD */ rc = osd_start(lsi, sb->s_flags); @@ -1829,28 +2041,25 @@ void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd) if (has_ir) { int new_soft = soft; - int new_hard = hard; /* adjust timeout value by imperative recovery */ - new_soft = (soft * factor) / OBD_IR_FACTOR_MAX; - new_hard = (hard * factor) / OBD_IR_FACTOR_MAX; - /* make sure the timeout is not too short */ new_soft = max(min, new_soft); - new_hard = max(new_soft, new_hard); LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery " "window shrunk from %d-%d down to %d-%d\n", - obd->obd_name, soft, hard, new_soft, new_hard); + obd->obd_name, soft, hard, new_soft, hard); soft = new_soft; - hard = new_hard; + } else { + LCONSOLE_INFO("%s: Imperative Recovery not enabled, recovery " + "window %d-%d\n", obd->obd_name, soft, hard); } /* we're done */ - obd->obd_recovery_timeout = max(obd->obd_recovery_timeout, soft); + obd->obd_recovery_timeout = max_t(time64_t, obd->obd_recovery_timeout, + soft); obd->obd_recovery_time_hard = hard; obd->obd_recovery_ir_factor = factor; } -EXPORT_SYMBOL(server_calc_timeout);