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=ad352376f943904ef5c0f4765aabf08a330801eb;hb=d5be104cc9b0c7a71b30aa5feb16873aa30803a9;hpb=d23a8edaa726f50cc48a270ec2905ec18401655f diff --git a/lustre/obdclass/obd_mount_server.c b/lustre/obdclass/obd_mount_server.c index ad35237..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); } @@ -84,8 +81,7 @@ static struct lustre_mount_info *server_find_mount(const char *name) /* we must register an obd for a mount before we call the setup routine. *_setup will call lustre_get_mount to get the mnt struct by obd_name, since we can't pass the pointer to setup. */ -static int server_register_mount(const char *name, struct super_block *sb, - struct vfsmount *mnt) +static int server_register_mount(const char *name, struct super_block *sb) { struct lustre_mount_info *lmi; char *name_cp; @@ -114,12 +110,11 @@ static int server_register_mount(const char *name, struct super_block *sb, } lmi->lmi_name = name_cp; lmi->lmi_sb = sb; - lmi->lmi_mnt = mnt; - 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); - CDEBUG(D_MOUNT, "reg_mnt %p from %s\n", lmi->lmi_mnt, name); + CDEBUG(D_MOUNT, "register mount %p from %s\n", sb, name); RETURN(0); } @@ -138,10 +133,10 @@ static int server_deregister_mount(const char *name) RETURN(-ENOENT); } - CDEBUG(D_MOUNT, "dereg_mnt %p from %s\n", lmi->lmi_mnt, 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); @@ -166,37 +161,28 @@ struct lustre_mount_info *server_get_mount(const char *name) } lsi = s2lsi(lmi->lmi_sb); - cfs_atomic_inc(&lsi->lsi_mounts); + atomic_inc(&lsi->lsi_mounts); - CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d\n", lmi->lmi_mnt, - name, cfs_atomic_read(&lsi->lsi_mounts)); + CDEBUG(D_MOUNT, "get mount %p from %s, refs=%d\n", lmi->lmi_sb, + name, atomic_read(&lsi->lsi_mounts)); RETURN(lmi); } EXPORT_SYMBOL(server_get_mount); -/* - * Used by mdt to get mount_info from obdname. - * There are no blocking when using the mount_info. - * Do not use server_get_mount for this purpose. +/** + * server_put_mount: to be called from obd_cleanup methods + * @name: obd name + * @dereg_mnt: 0 or 1 depending on whether the mount is to be deregistered or + * not + * + * The caller decides whether server_deregister_mount() needs to be called or + * not. Calling of server_deregister_mount() does not depend on refcounting on + * lsi because we could have say the mgs and mds on the same node and we + * unmount the mds, then the ref on the lsi would still be non-zero but we + * would still want to deregister the mds mount. */ -struct lustre_mount_info *server_get_mount_2(const char *name) -{ - struct lustre_mount_info *lmi; - ENTRY; - - mutex_lock(&lustre_mount_info_lock); - lmi = server_find_mount(name); - mutex_unlock(&lustre_mount_info_lock); - if (!lmi) - CERROR("Can't find mount for %s\n", name); - - RETURN(lmi); -} -EXPORT_SYMBOL(server_get_mount_2); - -/* to be called from obd_cleanup methods */ -int server_put_mount(const char *name, struct vfsmount *mnt) +int server_put_mount(const char *name, bool dereg_mnt) { struct lustre_mount_info *lmi; struct lustre_sb_info *lsi; @@ -211,33 +197,25 @@ int server_put_mount(const char *name, struct vfsmount *mnt) } lsi = s2lsi(lmi->lmi_sb); - CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d\n", - lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts)); + CDEBUG(D_MOUNT, "put mount %p from %s, refs=%d\n", + lmi->lmi_sb, name, atomic_read(&lsi->lsi_mounts)); if (lustre_put_lsi(lmi->lmi_sb)) - CDEBUG(D_MOUNT, "Last put of mnt %p from %s\n", - lmi->lmi_mnt, name); + CDEBUG(D_MOUNT, "Last put of mount %p from %s\n", + lmi->lmi_sb, name); - /* this obd should never need the mount again */ - server_deregister_mount(name); + if (dereg_mnt) + /* this obd should never need the mount again */ + server_deregister_mount(name); RETURN(0); } EXPORT_SYMBOL(server_put_mount); -/* Corresponding to server_get_mount_2 */ -int server_put_mount_2(const char *name, struct vfsmount *mnt) -{ - ENTRY; - RETURN(0); -} -EXPORT_SYMBOL(server_put_mount_2); - /* Set up a MGS to serve startup logs */ static int server_start_mgs(struct super_block *sb) { struct lustre_sb_info *lsi = s2lsi(sb); - struct vfsmount *mnt = lsi->lsi_srv_mnt; struct lustre_mount_info *lmi; int rc = 0; ENTRY; @@ -254,12 +232,12 @@ static int server_start_mgs(struct super_block *sb) CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME); - rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt); + rc = server_register_mount(LUSTRE_MGS_OBDNAME, 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), @@ -281,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 */ @@ -300,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; @@ -309,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) @@ -318,67 +303,42 @@ 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); } -static int is_mdc_device(const char *devname) +static inline bool is_mdc_device(const char *devname) { char *ptr; ptr = strrchr(devname, '-'); - if (ptr != NULL && strcmp(ptr, "-mdc") == 0) - return 1; - - return 0; + return ptr != NULL && strcmp(ptr, "-mdc") == 0; } -static inline int tgt_is_mdt0(const char *tgtname) +static inline bool tgt_is_mdt(const char *tgtname, __u32 *idx) { - __u32 idx; - int type; + int type; - type = server_name2index(tgtname, &idx, NULL); - if (type != LDD_F_SV_TYPE_MDT) - return 0; + type = server_name2index(tgtname, idx, NULL); - return idx == 0; -} - -static inline int is_mdc_for_mdt0(const char *devname) -{ - char *ptr; - - if (!is_mdc_device(devname)) - return 0; - - ptr = strrchr(devname, '-'); - if (ptr == NULL) - return 0; - - *ptr = 0; - if (tgt_is_mdt0(devname)) { - *ptr = '-'; - return 1; - } - *ptr = '-'; - return 0; + return type == LDD_F_SV_TYPE_MDT; } /** - * Convert OST/MDT name(fsname-OSTxxxx) to a lwp name - * (fsname-MDT0000-lwp-OSTxxxx) + * Convert OST/MDT name(fsname-{MDT,OST}xxxx) to a lwp name with the @idx:yyyy + * (fsname-MDTyyyy-lwp-{MDT,OST}xxxx) **/ -int tgt_name2lwpname(const char *svname, char *lwpname) +int tgt_name2lwp_name(const char *tgt_name, char *lwp_name, int len, __u32 idx) { char *fsname; const char *tgt; @@ -389,39 +349,56 @@ int tgt_name2lwpname(const char *svname, char *lwpname) if (fsname == NULL) RETURN(-ENOMEM); - rc = server_name2fsname(svname, fsname, &tgt); + rc = server_name2fsname(tgt_name, fsname, &tgt); if (rc != 0) { - CERROR("%s: failed to get fsname from svname. %d\n", - svname, rc); + CERROR("%s: failed to get fsname from tgt_name: rc = %d\n", + tgt_name, rc); GOTO(cleanup, rc); } if (*tgt != '-' && *tgt != ':') { - CERROR("%s: invalid svname name!\n", svname); + CERROR("%s: invalid tgt_name name!\n", tgt_name); GOTO(cleanup, rc = -EINVAL); } tgt++; if (strncmp(tgt, "OST", 3) != 0 && strncmp(tgt, "MDT", 3) != 0) { - CERROR("%s is not an OST or MDT target!\n", svname); + CERROR("%s is not an OST or MDT target!\n", tgt_name); GOTO(cleanup, rc = -EINVAL); } - sprintf(lwpname, "%s-MDT0000-%s-%s", fsname, LUSTRE_LWP_NAME, tgt); + snprintf(lwp_name, len, "%s-MDT%04x-%s-%s", + fsname, idx, LUSTRE_LWP_NAME, tgt); + + GOTO(cleanup, rc = 0); + cleanup: if (fsname != NULL) OBD_FREE(fsname, MTI_NAME_MAXLEN); - RETURN(rc); + + return rc; } -EXPORT_SYMBOL(tgt_name2lwpname); +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", @@ -432,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); } @@ -453,54 +427,136 @@ 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); - if (*exp != NULL && cb_func != NULL) + 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 (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); -static void lustre_notify_lwp_list(struct obd_export *exp) +struct obd_export *lustre_find_lwp_by_index(const char *dev, __u32 idx) { - struct lwp_register_item *lri, *tmp; + struct lustre_mount_info *lmi; + struct lustre_sb_info *lsi; + struct obd_device *lwp; + struct obd_export *exp = NULL; + char fsname[16]; + char lwp_name[24]; + int rc; + + lmi = server_get_mount(dev); + if (lmi == NULL) + return NULL; + + lsi = s2lsi(lmi->lmi_sb); + rc = server_name2fsname(lsi->lsi_svname, fsname, NULL); + if (rc != 0) { + CERROR("%s: failed to get fsname: rc = %d\n", + lsi->lsi_svname, rc); + goto err_lmi; + } + + snprintf(lwp_name, sizeof(lwp_name), "%s-MDT%04x", fsname, idx); + spin_lock(&lsi->lsi_lwp_lock); + list_for_each_entry(lwp, &lsi->lsi_lwp_list, obd_lwp_list) { + char *ptr = strstr(lwp->obd_name, lwp_name); + + if (ptr != NULL && lwp->obd_lwp_export != NULL) { + exp = class_export_get(lwp->obd_lwp_export); + break; + } + } + spin_unlock(&lsi->lsi_lwp_lock); + +err_lmi: + server_put_mount(dev, false); + + return exp; +} +EXPORT_SYMBOL(lustre_find_lwp_by_index); + +void lustre_notify_lwp_list(struct obd_export *exp) +{ + 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; @@ -515,7 +571,7 @@ static int lustre_lwp_connect(struct obd_device *lwp) if (rc != 0) RETURN(rc); - lu_context_init(&session_ctx, LCT_SESSION); + lu_context_init(&session_ctx, LCT_SERVER_SESSION); session_ctx.lc_thread = NULL; lu_context_enter(&session_ctx); env.le_ses = &session_ctx; @@ -526,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; + 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); @@ -543,10 +603,15 @@ static int lustre_lwp_connect(struct obd_device *lwp) /* Use lwp name as the uuid, so we find the export by lwp name later */ memcpy(uuid->uuid, lwp->obd_name, strlen(lwp->obd_name)); rc = obd_connect(&env, &exp, lwp, uuid, data, NULL); - if (rc != 0) + if (rc != 0) { CERROR("%s: connect failed: rc = %d\n", lwp->obd_name, rc); - else - lustre_notify_lwp_list(exp); + } else { + if (unlikely(lwp->obd_lwp_export != NULL)) + class_export_put(lwp->obd_lwp_export); + lwp->obd_lwp_export = class_export_get(exp); + } + + GOTO(out, rc); out: if (data != NULL) @@ -558,16 +623,16 @@ out: lu_context_exit(&session_ctx); lu_context_fini(&session_ctx); - RETURN(rc); + return rc; } /** - * lwp is used by slaves (Non-MDT0 targets) to manage the connection - * to MDT0. + * lwp is used by slaves (Non-MDT0 targets) to manage the connection to MDT0, + * or from the OSTx to MDTy. **/ -static int lustre_lwp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi) +static int lustre_lwp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi, + __u32 idx) { - struct obd_connect_data *data = NULL; struct obd_device *obd; char *lwpname = NULL; char *lwpuuid = NULL; @@ -576,18 +641,18 @@ static int lustre_lwp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi) rc = class_add_uuid(lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid); - if (rc) { + if (rc != 0) { CERROR("%s: Can't add uuid: rc =%d\n", lsi->lsi_svname, rc); - GOTO(out, rc); + RETURN(rc); } OBD_ALLOC(lwpname, MTI_NAME_MAXLEN); if (lwpname == NULL) GOTO(out, rc = -ENOMEM); - rc = tgt_name2lwpname(lsi->lsi_svname, lwpname); + rc = tgt_name2lwp_name(lsi->lsi_svname, lwpname, MTI_NAME_MAXLEN, idx); if (rc != 0) { - CERROR("%s: failed to generate lwp name. %d\n", + CERROR("%s: failed to generate lwp name: rc = %d\n", lsi->lsi_svname, rc); GOTO(out, rc); } @@ -599,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); @@ -608,23 +673,30 @@ 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); - if (rc != 0) + 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); + list_add_tail(&obd->obd_lwp_list, &lsi->lsi_lwp_list); + spin_unlock(&lsi->lsi_lwp_lock); + } else { CERROR("%s: connect failed: rc = %d\n", lwpname, rc); + } + + GOTO(out, rc); + out: - if (data != NULL) - OBD_FREE_PTR(data); if (lwpname != NULL) OBD_FREE(lwpname, MTI_NAME_MAXLEN); if (lwpuuid != NULL) OBD_FREE(lwpuuid, MTI_NAME_MAXLEN); - RETURN(rc); + return rc; } /* the caller is responsible for memory free */ static struct obd_device *lustre_find_lwp(struct lustre_sb_info *lsi, - char **lwpname, char **logname) + char **lwpname, __u32 idx) { struct obd_device *lwp; int rc = 0; @@ -637,22 +709,9 @@ static struct obd_device *lustre_find_lwp(struct lustre_sb_info *lsi, if (*lwpname == NULL) RETURN(ERR_PTR(-ENOMEM)); - if (logname != NULL) { - OBD_ALLOC(*logname, MTI_NAME_MAXLEN); - if (*logname == NULL) - GOTO(out, rc = -ENOMEM); - rc = server_name2fsname(lsi->lsi_svname, *lwpname, NULL); - if (rc != 0) { - CERROR("%s: failed to get fsname from svname. %d\n", - lsi->lsi_svname, rc); - GOTO(out, rc = -EINVAL); - } - sprintf(*logname, "%s-client", *lwpname); - } - - rc = tgt_name2lwpname(lsi->lsi_svname, *lwpname); + rc = tgt_name2lwp_name(lsi->lsi_svname, *lwpname, MTI_NAME_MAXLEN, idx); if (rc != 0) { - CERROR("%s: failed to generate lwp name. %d\n", + CERROR("%s: failed to generate lwp name: rc = %d\n", lsi->lsi_svname, rc); GOTO(out, rc = -EINVAL); } @@ -665,10 +724,6 @@ out: OBD_FREE(*lwpname, MTI_NAME_MAXLEN); *lwpname = NULL; } - if (logname != NULL && *logname != NULL) { - OBD_FREE(*logname, MTI_NAME_MAXLEN); - *logname = NULL; - } lwp = ERR_PTR(rc); } @@ -676,7 +731,7 @@ out: } static int lustre_lwp_add_conn(struct lustre_cfg *cfg, - struct lustre_sb_info *lsi) + struct lustre_sb_info *lsi, __u32 idx) { struct lustre_cfg_bufs *bufs = NULL; struct lustre_cfg *lcfg = NULL; @@ -685,7 +740,7 @@ static int lustre_lwp_add_conn(struct lustre_cfg *cfg, int rc; ENTRY; - lwp = lustre_find_lwp(lsi, &lwpname, NULL); + lwp = lustre_find_lwp(lsi, &lwpname, idx); if (IS_ERR(lwp)) { CERROR("%s: can't find lwp device.\n", lsi->lsi_svname); GOTO(out, rc = PTR_ERR(lwp)); @@ -700,17 +755,22 @@ 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); + 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); -out: + if (lcfg) + OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, + lcfg->lcfg_buflens)); +out_cfg: if (bufs != NULL) OBD_FREE_PTR(bufs); - if (lcfg != NULL) - lustre_cfg_free(lcfg); +out: if (lwpname != NULL) OBD_FREE(lwpname, MTI_NAME_MAXLEN); RETURN(rc); @@ -720,25 +780,25 @@ out: * Retrieve MDT nids from the client log, then start the lwp device. * there are only two scenarios which would include mdt nid. * 1. - * marker 5 (flags=0x01, v2.1.54.0) lustre-MDT0000 'add mdc' xxx- + * marker 5 (flags=0x01, v2.1.54.0) lustre-MDTyyyy 'add mdc' xxx- * add_uuid nid=192.168.122.162@tcp(0x20000c0a87aa2) 0: 1:192.168.122.162@tcp - * attach 0:lustre-MDT0000-mdc 1:mdc 2:lustre-clilmv_UUID - * setup 0:lustre-MDT0000-mdc 1:lustre-MDT0000_UUID 2:192.168.122.162@tcp + * attach 0:lustre-MDTyyyy-mdc 1:mdc 2:lustre-clilmv_UUID + * setup 0:lustre-MDTyyyy-mdc 1:lustre-MDTyyyy_UUID 2:192.168.122.162@tcp * add_uuid nid=192.168.172.1@tcp(0x20000c0a8ac01) 0: 1:192.168.172.1@tcp - * add_conn 0:lustre-MDT0000-mdc 1:192.168.172.1@tcp - * modify_mdc_tgts add 0:lustre-clilmv 1:lustre-MDT0000_UUID xxxx - * marker 5 (flags=0x02, v2.1.54.0) lustre-MDT0000 'add mdc' xxxx- + * add_conn 0:lustre-MDTyyyy-mdc 1:192.168.172.1@tcp + * modify_mdc_tgts add 0:lustre-clilmv 1:lustre-MDTyyyy_UUID xxxx + * marker 5 (flags=0x02, v2.1.54.0) lustre-MDTyyyy 'add mdc' xxxx- * 2. - * marker 7 (flags=0x01, v2.1.54.0) lustre-MDT0000 'add failnid' xxxx- + * marker 7 (flags=0x01, v2.1.54.0) lustre-MDTyyyy 'add failnid' xxxx- * add_uuid nid=192.168.122.2@tcp(0x20000c0a87a02) 0: 1:192.168.122.2@tcp - * add_conn 0:lustre-MDT0000-mdc 1:192.168.122.2@tcp - * marker 7 (flags=0x02, v2.1.54.0) lustre-MDT0000 'add failnid' xxxx- + * add_conn 0:lustre-MDTyyyy-mdc 1:192.168.122.2@tcp + * marker 7 (flags=0x02, v2.1.54.0) lustre-MDTyyyy 'add failnid' xxxx- **/ 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; @@ -752,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)) { @@ -775,32 +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_mdt0(marker->cm_tgtname)) + if (!tgt_is_mdt(marker->cm_tgtname, &cfg->cfg_lwp_idx)) + GOTO(out, rc = 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); + 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) @@ -810,8 +874,28 @@ static int client_lwp_config_process(const struct lu_env *env, break; } case LCFG_ADD_CONN: { - if (is_mdc_for_mdt0(lustre_cfg_string(lcfg, 0))) - rc = lustre_lwp_add_conn(lcfg, lsi); + char *devname = lustre_cfg_string(lcfg, 0); + char *ptr; + __u32 idx = 0; + + if (!is_mdc_device(devname)) + break; + + ptr = strrchr(devname, '-'); + if (ptr == NULL) + break; + + *ptr = 0; + if (!tgt_is_mdt(devname, &idx)) { + *ptr = '-'; + break; + } + *ptr = '-'; + + if (IS_MDT(lsi) && idx != 0) + break; + + rc = lustre_lwp_add_conn(lcfg, lsi, idx); break; } default: @@ -823,67 +907,85 @@ out: static int lustre_disconnect_lwp(struct super_block *sb) { - struct lustre_sb_info *lsi = s2lsi(sb); + struct lustre_sb_info *lsi = s2lsi(sb); struct obd_device *lwp; - char *lwpname = NULL; char *logname = NULL; - struct lustre_cfg *lcfg = NULL; - struct lustre_cfg_bufs *bufs = NULL; - struct config_llog_instance *cfg = NULL; - int rc; + struct lustre_cfg_bufs *bufs = NULL; + struct config_llog_instance *cfg = NULL; + int rc = 0; + int rc1 = 0; ENTRY; - lwp = lustre_find_lwp(lsi, &lwpname, &logname); - if (IS_ERR(lwp) && PTR_ERR(lwp) != -ENOENT) - GOTO(out, rc = PTR_ERR(lwp)); + if (likely(lsi->lsi_lwp_started)) { + OBD_ALLOC(logname, MTI_NAME_MAXLEN); + if (logname == NULL) + RETURN(-ENOMEM); - LASSERT(lwpname != NULL); - LASSERT(logname != NULL); + rc = server_name2fsname(lsi->lsi_svname, logname, NULL); + if (rc != 0) { + CERROR("%s: failed to get fsname from svname: " + "rc = %d\n", lsi->lsi_svname, rc); + GOTO(out, rc = -EINVAL); + } - OBD_ALLOC_PTR(cfg); - if (cfg == NULL) - GOTO(out, rc = -ENOMEM); + strcat(logname, "-client"); + OBD_ALLOC_PTR(cfg); + if (cfg == NULL) + GOTO(out, rc = -ENOMEM); - /* end log first */ - cfg->cfg_instance = sb; - rc = lustre_end_log(sb, logname, cfg); - if (rc != 0) { - CERROR("%s: Can't end config log %s.\n", lwpname, logname); - GOTO(out, rc); - } + /* end log first */ + cfg->cfg_instance = ll_get_cfg_instance(sb); + rc = lustre_end_log(sb, logname, cfg); + if (rc != 0 && rc != -ENOENT) + GOTO(out, rc); - if (PTR_ERR(lwp) == -ENOENT) { - CDEBUG(D_CONFIG, "%s: lwp device wasn't started.\n", - lsi->lsi_svname); - GOTO(out, rc = 0); + lsi->lsi_lwp_started = 0; } OBD_ALLOC_PTR(bufs); if (bufs == NULL) GOTO(out, rc = -ENOMEM); - 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) - GOTO(out, rc = -ENOMEM); + list_for_each_entry(lwp, &lsi->lsi_lwp_list, obd_lwp_list) { + struct lustre_cfg *lcfg; + + if (likely(lwp->obd_lwp_export != NULL)) { + class_export_put(lwp->obd_lwp_export); + lwp->obd_lwp_export = NULL; + } + + lustre_cfg_bufs_reset(bufs, lwp->obd_name); + lustre_cfg_bufs_set_string(bufs, 1, 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); + 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; + } + } + + GOTO(out, rc); - /* 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); out: - if (lcfg) - lustre_cfg_free(lcfg); - if (bufs) + if (bufs != NULL) OBD_FREE_PTR(bufs); - if (cfg) + if (cfg != NULL) OBD_FREE_PTR(cfg); - if (lwpname) - OBD_FREE(lwpname, MTI_NAME_MAXLEN); - if (logname) + if (logname != NULL) OBD_FREE(logname, MTI_NAME_MAXLEN); - RETURN(rc); + + return rc1 != 0 ? rc1 : rc; } /** @@ -892,72 +994,74 @@ out: static int lustre_stop_lwp(struct super_block *sb) { struct lustre_sb_info *lsi = s2lsi(sb); - struct obd_device *lwp = NULL; - char *lwpname = NULL; - int rc = 0; + struct obd_device *lwp; + int rc = 0; + int rc1 = 0; ENTRY; - lwp = lustre_find_lwp(lsi, &lwpname, NULL); - if (IS_ERR(lwp)) { - CDEBUG(PTR_ERR(lwp) == -ENOENT ? D_CONFIG : D_ERROR, - "%s: lwp wasn't started.\n", lsi->lsi_svname); - GOTO(out, rc = 0); + 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; + rc = class_manual_cleanup(lwp); + if (rc != 0) { + CERROR("%s: fail to stop LWP: rc = %d\n", + lwp->obd_name, rc); + rc1 = rc; + } } - lwp->obd_force = 1; - rc = class_manual_cleanup(lwp); - -out: - if (lwpname != NULL) - OBD_FREE(lwpname, MTI_NAME_MAXLEN); - RETURN(rc); + RETURN(rc1 != 0 ? rc1 : rc); } /** - * Start the lwp(fsname-MDT0000-lwp-OSTxxxx) for an OST or MDT target, - * which would be used to establish connection from OST to MDT0. + * Start the lwp(fsname-MDTyyyy-lwp-{MDT,OST}xxxx) for a MDT/OST or MDT target. **/ static int lustre_start_lwp(struct super_block *sb) { struct lustre_sb_info *lsi = s2lsi(sb); struct config_llog_instance *cfg = NULL; - struct obd_device *lwp; - char *lwpname = NULL; - char *logname = NULL; + char *logname; int rc; ENTRY; - lwp = lustre_find_lwp(lsi, &lwpname, &logname); + if (unlikely(lsi->lsi_lwp_started)) + RETURN(0); - /* the lwp device already stared */ - if (lwp && !IS_ERR(lwp)) - GOTO(out, rc = 0); - - if (PTR_ERR(lwp) != -ENOENT) - GOTO(out, rc = PTR_ERR(lwp)); + OBD_ALLOC(logname, MTI_NAME_MAXLEN); + if (logname == NULL) + RETURN(-ENOMEM); - LASSERT(lwpname != NULL); - LASSERT(logname != NULL); + rc = server_name2fsname(lsi->lsi_svname, logname, NULL); + if (rc != 0) { + CERROR("%s: failed to get fsname from svname: rc = %d\n", + lsi->lsi_svname, rc); + GOTO(out, rc = -EINVAL); + } + strcat(logname, "-client"); OBD_ALLOC_PTR(cfg); if (cfg == NULL) 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; + + GOTO(out, rc); + out: - if (lwpname != NULL) - OBD_FREE(lwpname, MTI_NAME_MAXLEN); - if (logname != NULL) - OBD_FREE(logname, MTI_NAME_MAXLEN); + OBD_FREE(logname, MTI_NAME_MAXLEN); if (cfg != NULL) OBD_FREE_PTR(cfg); - RETURN(rc); + + 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) @@ -1005,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; @@ -1049,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; @@ -1080,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); @@ -1104,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, @@ -1117,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; } @@ -1183,12 +1306,12 @@ out: /** Start server targets: MDTs and OSTs */ -static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) +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; @@ -1203,7 +1326,7 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) 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); @@ -1222,7 +1345,7 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) 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); @@ -1232,13 +1355,15 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) 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. */ - if (lsi->lsi_srv_mnt) { - rc = server_mgc_set_fs(lsi->lsi_mgc, sb); - if (rc) - GOTO(out_stop_service, rc); - } + rc = server_mgc_set_fs(&mgc_env, lsi->lsi_mgc, sb); + if (rc) + GOTO(out_env, rc); /* Register with MGS */ rc = server_register_target(lsi); @@ -1247,13 +1372,14 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) /* Let the target look up the mount using the target's name (we can't pass the sb or mnt through class_process_config.) */ - rc = server_register_mount(lsi->lsi_svname, sb, mnt); + rc = server_register_mount(lsi->lsi_svname, sb); if (rc) GOTO(out_mgc, rc); /* 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", @@ -1284,17 +1410,16 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) /* 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; - lu_context_init(&session_ctx, LCT_SESSION); + lu_context_init(&session_ctx, LCT_SERVER_SESSION); session_ctx.lc_thread = NULL; lu_context_enter(&session_ctx); env.le_ses = &session_ctx; @@ -1317,9 +1442,9 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt) out_mgc: /* Release the mgc fs for others to use */ - if (lsi->lsi_srv_mnt) - 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); @@ -1329,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; @@ -1342,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; } - /* XXX: a temp. solution for components using fsfilt + 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); @@ -1424,9 +1549,10 @@ static void server_put_super(struct super_block *sb) int rc; rc = lustre_disconnect_lwp(sb); - if (rc && rc != ETIMEDOUT) - CERROR("%s: failed to disconnect lwp. (rc=%d)\n", - tmpname, rc); + if (rc != 0 && rc != -ETIMEDOUT && + rc != -ENOTCONN && rc != -ESHUTDOWN) + CWARN("%s: failed to disconnect lwp: rc= %d\n", + tmpname, rc); } /* Stop the target */ @@ -1441,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); @@ -1547,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. */ @@ -1554,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) { @@ -1572,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) @@ -1579,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); @@ -1613,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); @@ -1625,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, @@ -1638,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) { @@ -1651,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); @@ -1672,9 +1916,6 @@ static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags) obd->obd_lvfs_ctxt.dt = lsi->lsi_dt_dev; dt_conf_get(NULL, lsi->lsi_dt_dev, &p); - - lsi->lsi_srv_mnt = p.ddp_mnt; - out: RETURN(rc); } @@ -1690,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); @@ -1730,7 +1976,7 @@ int server_fill_super(struct super_block *sb) /* Set up all obd devices for service */ if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) && (IS_OST(lsi) || IS_MDT(lsi))) { - rc = server_start_targets(sb, lsi->lsi_srv_mnt); + rc = server_start_targets(sb); if (rc < 0) { CERROR("Unable to start targets: %d\n", rc); GOTO(out_mnt, rc); @@ -1795,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);