* 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, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define PRINT_CMD CDEBUG
#define PRINT_MASK (D_SUPER | D_CONFIG)
+#include <linux/types.h>
+#include <linux/selinux.h>
+#include <linux/statfs.h>
#include <obd.h>
#include <obd_class.h>
#include <lustre/lustre_user.h>
#ifdef HAVE_KERNEL_LOCKED
#include <linux/smp_lock.h>
#endif
-#ifdef HAVE_SELINUX_IS_ENABLED
-#include <linux/selinux.h>
-#endif
/*********** mount lookup *********/
-DEFINE_MUTEX(lustre_mount_info_lock);
-static CFS_LIST_HEAD(server_mount_info_list);
+static DEFINE_MUTEX(lustre_mount_info_lock);
+static struct list_head server_mount_info_list =
+ LIST_HEAD_INIT(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);
}
}
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);
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);
}
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)
+int server_put_mount(const char *name, bool dereg_mnt)
{
struct lustre_mount_info *lmi;
struct lustre_sb_info *lsi;
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)
{
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),
{
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 */
}
EXPORT_SYMBOL(tgt_name2lwp_name);
-static CFS_LIST_HEAD(lwp_register_list);
-DEFINE_MUTEX(lwp_register_list_lock);
+static struct list_head lwp_register_list =
+ LIST_HEAD_INIT(lwp_register_list);
+static DEFINE_MUTEX(lwp_register_list_lock);
int lustre_register_lwp_item(const char *lwpname, struct obd_export **exp,
register_lwp_cb cb_func, void *cb_data)
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);
+ list_add(&lri->lri_list, &lwp_register_list);
if (*exp != NULL && cb_func != NULL)
cb_func(cb_data);
struct lwp_register_item *lri, *tmp;
mutex_lock(&lwp_register_list_lock);
- cfs_list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) {
+ list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) {
if (exp == lri->lri_exp) {
if (*exp)
class_export_put(*exp);
- cfs_list_del(&lri->lri_list);
+ list_del(&lri->lri_list);
OBD_FREE_PTR(lri);
break;
}
char lwp_name[24];
int rc;
- lmi = server_get_mount_2(dev);
+ lmi = server_get_mount(dev);
if (lmi == NULL)
return NULL;
if (rc != 0) {
CERROR("%s: failed to get fsname: rc = %d\n",
lsi->lsi_svname, rc);
- return NULL;
+ goto err_lmi;
}
snprintf(lwp_name, sizeof(lwp_name), "%s-MDT%04x", fsname, idx);
}
spin_unlock(&lsi->lsi_lwp_lock);
+err_lmi:
+ server_put_mount(dev, false);
+
return exp;
}
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;
LASSERT(exp != NULL);
mutex_lock(&lwp_register_list_lock);
- cfs_list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) {
+ list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) {
if (strcmp(exp->exp_obd->obd_name, lri->lri_name))
continue;
if (*lri->lri_exp != NULL)
}
mutex_unlock(&lwp_register_list_lock);
}
+EXPORT_SYMBOL(lustre_notify_lwp_list);
static int lustre_lwp_connect(struct obd_device *lwp)
{
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_LIGHTWEIGHT | OBD_CONNECT_LFSCK |
+ OBD_CONNECT_BULK_MBITS;
OBD_ALLOC_PTR(uuid);
if (uuid == NULL)
GOTO(out, rc = -ENOMEM);
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);
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);
lustre_cfg_string(cfg, 1));
lcfg = lustre_cfg_new(LCFG_ADD_CONN, bufs);
-
+ if (lcfg == NULL)
+ GOTO(out_cfg, rc = -ENOMEM);
rc = class_add_conn(lwp, lcfg);
if (rc)
CERROR("%s: can't add conn: rc = %d\n", lwpname, rc);
-out:
- if (bufs != NULL)
- OBD_FREE_PTR(bufs);
if (lcfg != NULL)
lustre_cfg_free(lcfg);
+out_cfg:
+ if (bufs != NULL)
+ OBD_FREE_PTR(bufs);
+out:
if (lwpname != NULL)
OBD_FREE(lwpname, MTI_NAME_MAXLEN);
RETURN(rc);
*ptr = '-';
break;
}
-
*ptr = '-';
+
+ if (IS_MDT(lsi) && idx != 0)
+ break;
+
rc = lustre_lwp_add_conn(lcfg, lsi, idx);
break;
}
/* end log first */
cfg->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;
cfg->cfg_callback = client_lwp_config_process;
cfg->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);
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)
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,
"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;
}
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);
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);
static int lsi_prepare(struct lustre_sb_info *lsi)
{
+ const char *osd_type;
+ const char *fstype;
__u32 index;
int rc;
ENTRY;
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);
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);
return -EOPNOTSUPP;
}
-const struct inode_operations server_inode_operations = {
+static const struct inode_operations server_inode_operations = {
.setxattr = lustre_setxattr,
.getxattr = lustre_getxattr,
.listxattr = lustre_listxattr,
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);
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);
int rc;
ENTRY;
+ /* to simulate target mount race */
+ OBD_RACE(OBD_FAIL_TGT_MOUNT_RACE);
+
rc = lsi_prepare(lsi);
if (rc)
RETURN(rc);
obd->obd_recovery_time_hard = hard;
obd->obd_recovery_ir_factor = factor;
}
-EXPORT_SYMBOL(server_calc_timeout);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff