X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Fobd_mount_server.c;h=d3854db973f11ff36f9f8d4dfc1c39a7b824900b;hp=9945ef0fd6da98890c50fb733766012a7b2d73d9;hb=5c883ea2748ae9e430a9cd863a9b630b2a74440a;hpb=bccfc65d04dbd59bedb5dc1509bbdc732fc09b53 diff --git a/lustre/obdclass/obd_mount_server.c b/lustre/obdclass/obd_mount_server.c index 9945ef0..d3854db 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, 2015, Intel Corporation. + * Copyright (c) 2013, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -47,29 +43,25 @@ #define PRINT_MASK (D_SUPER | D_CONFIG) #include +#ifdef HAVE_LINUX_SELINUX_IS_ENABLED #include +#endif #include #include -#ifdef HAVE_KERNEL_LOCKED -#include -#endif - -#include -#include +#include #include #include -#include +#include #include -#include +#include #include #include /*********** mount lookup *********/ static DEFINE_MUTEX(lustre_mount_info_lock); -static struct list_head server_mount_info_list = - LIST_HEAD_INIT(server_mount_info_list); +static LIST_HEAD(server_mount_info_list); static struct lustre_mount_info *server_find_mount(const char *name) { @@ -387,8 +379,7 @@ cleanup: } EXPORT_SYMBOL(tgt_name2lwp_name); -static struct list_head lwp_register_list = - LIST_HEAD_INIT(lwp_register_list); +static LIST_HEAD(lwp_register_list); static DEFINE_SPINLOCK(lwp_register_list_lock); static void lustre_put_lwp_item(struct lwp_register_item *lri) @@ -407,6 +398,7 @@ int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp, { 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", @@ -427,7 +419,7 @@ int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp, RETURN(-ENOMEM); } memcpy(uuid->uuid, lwpname, strlen(lwpname)); - *exp = cfs_hash_lookup(lwp->obd_uuid_hash, uuid); + *exp = obd_uuid_lookup(lwp, uuid); OBD_FREE_PTR(uuid); } @@ -445,9 +437,11 @@ int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp, 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); @@ -458,18 +452,33 @@ EXPORT_SYMBOL(lustre_register_lwp_item); void lustre_deregister_lwp_item(struct obd_export **exp) { struct lwp_register_item *lri; + bool removed = false; + int repeat = 0; spin_lock(&lwp_register_list_lock); list_for_each_entry(lri, &lwp_register_list, lri_list) { if (exp == lri->lri_exp) { list_del_init(&lri->lri_list); - spin_unlock(&lwp_register_list_lock); - - lustre_put_lwp_item(lri); - return; + removed = true; + break; } } 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++; + schedule_timeout_interruptible(cfs_time_seconds(1)); + } + lustre_put_lwp_item(lri); } EXPORT_SYMBOL(lustre_deregister_lwp_item); @@ -496,7 +505,7 @@ struct obd_export *lustre_find_lwp_by_index(const char *dev, __u32 idx) } snprintf(lwp_name, sizeof(lwp_name), "%s-MDT%04x", fsname, idx); - spin_lock(&lsi->lsi_lwp_lock); + mutex_lock(&lsi->lsi_lwp_mutex); list_for_each_entry(lwp, &lsi->lsi_lwp_list, obd_lwp_list) { char *ptr = strstr(lwp->obd_name, lwp_name); @@ -505,7 +514,7 @@ struct obd_export *lustre_find_lwp_by_index(const char *dev, __u32 idx) break; } } - spin_unlock(&lsi->lsi_lwp_lock); + mutex_unlock(&lsi->lsi_lwp_mutex); err_lmi: server_put_mount(dev, false); @@ -527,11 +536,12 @@ again: if (*lri->lri_exp != NULL) continue; *lri->lri_exp = class_export_get(exp); + if (lri->lri_cb_func == NULL) + continue; atomic_inc(&lri->lri_ref); spin_unlock(&lwp_register_list_lock); - if (lri->lri_cb_func != NULL) - lri->lri_cb_func(lri->lri_cb_data); + lri->lri_cb_func(lri->lri_cb_data); lustre_put_lwp_item(lri); /* Others may have changed the list after we unlock, we have @@ -545,7 +555,7 @@ again: } 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; @@ -571,11 +581,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 | - OBD_CONNECT_BULK_MBITS; + 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); @@ -659,12 +672,12 @@ 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); + mutex_lock(&lsi->lsi_lwp_mutex); list_add_tail(&obd->obd_lwp_list, &lsi->lsi_lwp_list); - spin_unlock(&lsi->lsi_lwp_lock); + mutex_unlock(&lsi->lsi_lwp_mutex); } else { CERROR("%s: connect failed: rc = %d\n", lwpname, rc); } @@ -741,15 +754,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); @@ -781,7 +797,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; @@ -795,8 +811,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)) { @@ -818,35 +835,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) @@ -863,6 +880,20 @@ static int client_lwp_config_process(const struct lu_env *env, if (!is_mdc_device(devname)) break; + if (!(cfg->cfg_flags & CFG_F_MARKER)) { + CDEBUG(D_CONFIG, "Skipping add_conn for %s, rec %d\n", + devname, rec->lrh_index); + break; + } + + /* add_conn should follow by add_uuid. This + * guarantee lwp device was created + */ + if (!(cfg->cfg_flags & CFG_F_SKIP)) { + CWARN("Error at config for %s rec %d, add_conn should follow by add_uuid\n", + devname, rec->lrh_index); + break; + } ptr = strrchr(devname, '-'); if (ptr == NULL) break; @@ -916,7 +947,7 @@ 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 && rc != -ENOENT) GOTO(out, rc); @@ -928,6 +959,7 @@ static int lustre_disconnect_lwp(struct super_block *sb) if (bufs == NULL) GOTO(out, rc = -ENOMEM); + mutex_lock(&lsi->lsi_lwp_mutex); list_for_each_entry(lwp, &lsi->lsi_lwp_list, obd_lwp_list) { struct lustre_cfg *lcfg; @@ -938,21 +970,27 @@ 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) - GOTO(out, rc = -ENOMEM); + OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount, + bufs->lcfg_buflen)); + if (!lcfg) { + rc = -ENOMEM; + break; + } + 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); rc1 = rc; } } + mutex_unlock(&lsi->lsi_lwp_mutex); GOTO(out, rc); @@ -978,18 +1016,23 @@ static int lustre_stop_lwp(struct super_block *sb) int rc1 = 0; ENTRY; + mutex_lock(&lsi->lsi_lwp_mutex); while (!list_empty(&lsi->lsi_lwp_list)) { lwp = list_entry(lsi->lsi_lwp_list.next, struct obd_device, obd_lwp_list); list_del_init(&lwp->obd_lwp_list); lwp->obd_force = 1; + mutex_unlock(&lsi->lsi_lwp_mutex); + rc = class_manual_cleanup(lwp); if (rc != 0) { CERROR("%s: fail to stop LWP: rc = %d\n", lwp->obd_name, rc); rc1 = rc; } + mutex_lock(&lsi->lsi_lwp_mutex); } + mutex_unlock(&lsi->lsi_lwp_mutex); RETURN(rc1 != 0 ? rc1 : rc); } @@ -1025,7 +1068,7 @@ 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); /* need to remove config llog from mgc */ lsi->lsi_lwp_started = 1; @@ -1048,6 +1091,7 @@ static int server_stop_servers(int lsiflags) struct obd_device *obd = NULL; struct obd_type *type = NULL; int rc = 0; + bool type_last; ENTRY; mutex_lock(&server_start_lock); @@ -1056,23 +1100,32 @@ static int server_stop_servers(int lsiflags) /* if this was an MDT, and there are no more MDT's, clean up the MDS */ if (lsiflags & LDD_F_SV_TYPE_MDT) { obd = class_name2obd(LUSTRE_MDS_OBDNAME); - if (obd != NULL) - type = class_search_type(LUSTRE_MDT_NAME); - } - + type = class_search_type(LUSTRE_MDT_NAME); + } else if (lsiflags & LDD_F_SV_TYPE_OST) { /* if this was an OST, and there are no more OST's, clean up the OSS */ - if (lsiflags & LDD_F_SV_TYPE_OST) { obd = class_name2obd(LUSTRE_OSS_OBDNAME); - if (obd != NULL) - type = class_search_type(LUSTRE_OST_NAME); + type = class_search_type(LUSTRE_OST_NAME); } - if (obd != NULL && (type == NULL || type->typ_refcnt == 0)) { + /* server_stop_servers is a pair of server_start_targets + * Here we put type which was taken at server_start_targets. + * If type is NULL then there is a wrong logic around type or + * type reference. */ + LASSERTF(type, "Server flags %d, obd %s\n", lsiflags, + obd ? obd->obd_name : "NULL"); + + type_last = (atomic_read(&type->typ_refcnt) == 1); + + class_put_type(type); + if (obd != NULL && type_last) { obd->obd_force = 1; /* obd_fail doesn't mean much on a server obd */ rc = class_manual_cleanup(obd); } + /* put reference taken by class_search_type */ + kobject_put(&type->typ_kobj); + mutex_unlock(&server_start_lock); RETURN(rc); @@ -1093,7 +1146,7 @@ int server_mti_print(const char *title, struct mgs_target_info *mti) 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; @@ -1131,6 +1184,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; @@ -1162,6 +1222,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); @@ -1186,6 +1247,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, @@ -1199,6 +1261,15 @@ 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. */ + schedule_timeout_interruptible( + cfs_time_seconds(2)); + 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", @@ -1272,46 +1343,52 @@ static int server_start_targets(struct super_block *sb) struct config_llog_instance cfg; struct lu_env mgc_env; struct lu_device *dev; + char *name_service, *obd_name_service = NULL; + struct obd_type *type = NULL; int rc; ENTRY; CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname); + LASSERTF(IS_MDT(lsi) || IS_OST(lsi), "designed for MDT or OST only\n"); + if (IS_MDT(lsi)) { - /* make sure the MDS is started */ - mutex_lock(&server_start_lock); - obd = class_name2obd(LUSTRE_MDS_OBDNAME); - if (!obd) { - rc = lustre_start_simple(LUSTRE_MDS_OBDNAME, - LUSTRE_MDS_NAME, - LUSTRE_MDS_OBDNAME"_uuid", - NULL, NULL, NULL, NULL); - if (rc) { - mutex_unlock(&server_start_lock); - CERROR("failed to start MDS: %d\n", rc); - RETURN(rc); - } - } - mutex_unlock(&server_start_lock); + obd_name_service = LUSTRE_MDS_OBDNAME; + name_service = LUSTRE_MDS_NAME; + } else { + obd_name_service = LUSTRE_OSS_OBDNAME; + name_service = LUSTRE_OSS_NAME; } - /* If we're an OST, make sure the global OSS is running */ - if (IS_OST(lsi)) { - /* make sure OSS is started */ - mutex_lock(&server_start_lock); - obd = class_name2obd(LUSTRE_OSS_OBDNAME); - if (!obd) { - rc = lustre_start_simple(LUSTRE_OSS_OBDNAME, - LUSTRE_OSS_NAME, - LUSTRE_OSS_OBDNAME"_uuid", - NULL, NULL, NULL, NULL); - if (rc) { - mutex_unlock(&server_start_lock); - CERROR("failed to start OSS: %d\n", rc); - RETURN(rc); - } + /* make sure MDS/OSS is started */ + mutex_lock(&server_start_lock); + obd = class_name2obd(obd_name_service); + if (!obd) { + rc = lustre_start_simple(obd_name_service, name_service, + (IS_MDT(lsi) ? + LUSTRE_MDS_OBDNAME"_uuid" : + LUSTRE_OSS_OBDNAME"_uuid"), + NULL, NULL, NULL, NULL); + if (rc) { + mutex_unlock(&server_start_lock); + CERROR("failed to start %s: %d\n", + obd_name_service, rc); + RETURN(rc); } + } + /* hold a type reference and put it at server_stop_servers */ + type = class_get_type(IS_MDT(lsi) ? + LUSTRE_MDT_NAME : LUSTRE_OST_NAME); + if (!type) { mutex_unlock(&server_start_lock); + GOTO(out_stop_service, rc = -ENODEV); + } + lsi->lsi_server_started = 1; + mutex_unlock(&server_start_lock); + if (OBD_FAIL_PRECHECK(OBD_FAIL_OBD_STOP_MDS_RACE) && + IS_MDT(lsi)) { + OBD_RACE(OBD_FAIL_OBD_STOP_MDS_RACE); + msleep(2 * MSEC_PER_SEC); } rc = lu_env_init(&mgc_env, LCT_MG_THREAD); @@ -1338,6 +1415,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", @@ -1368,9 +1446,6 @@ 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) { @@ -1407,8 +1482,9 @@ out_mgc: out_env: lu_env_fini(&mgc_env); out_stop_service: - if (rc != 0) - server_stop_servers(lsi->lsi_flags); + /* in case of error upper function call + * server_put_super->server_stop_servers() + */ RETURN(rc); } @@ -1494,6 +1570,7 @@ static void server_put_super(struct super_block *sb) char *tmpname, *extraname = NULL; int tmpname_sz; int lsiflags = lsi->lsi_flags; + bool stop_servers = lsi->lsi_server_started; ENTRY; LASSERT(IS_SERVER(lsi)); @@ -1546,6 +1623,13 @@ static void server_put_super(struct super_block *sb) * to .put_super, so we better make sure we clean up! */ obd->obd_force = 1; class_manual_cleanup(obd); + if (OBD_FAIL_PRECHECK(OBD_FAIL_OBD_STOP_MDS_RACE)) { + int idx; + server_name2index(lsi->lsi_svname, &idx, NULL); + /* sleeping for MDT0001 */ + if (idx == 1) + OBD_RACE(OBD_FAIL_OBD_STOP_MDS_RACE); + } } else { CERROR("no obd %s\n", lsi->lsi_svname); server_deregister_mount(lsi->lsi_svname); @@ -1576,7 +1660,8 @@ static void server_put_super(struct super_block *sb) /* Stop the servers (MDS, OSS) if no longer needed. We must wait until the target is really gone so that our type refcount check is right. */ - server_stop_servers(lsiflags); + if (stop_servers) + server_stop_servers(lsiflags); /* In case of startup or cleanup err, stop related obds */ if (extraname) { @@ -1638,6 +1723,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. */ @@ -1645,11 +1787,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) { @@ -1663,6 +1807,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) @@ -1670,12 +1815,55 @@ static ssize_t lustre_listxattr(struct dentry *d_entry, char *name, return -EOPNOTSUPP; } +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 @@ -1690,7 +1878,7 @@ static int server_fill_super_common(struct super_block *sb) sb->s_blocksize_bits = log2(sb->s_blocksize); sb->s_magic = LUSTRE_SUPER_MAGIC; sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */ - sb->s_flags |= MS_RDONLY; + sb->s_flags |= SB_RDONLY; sb->s_op = &server_ops; root = new_inode(sb); @@ -1704,6 +1892,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); @@ -1716,10 +1905,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, @@ -1729,7 +1918,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) { @@ -1792,8 +1981,10 @@ int server_fill_super(struct super_block *sb) 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); @@ -1896,27 +2087,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; }