* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel, Inc.
+ * Copyright (c) 2012, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
*
* Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
* Author: Mikhail Pershin <mike.pershin@intel.com>
+ * Author: Di Wang <di.wang@intel.com>
*/
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
#define DEBUG_SUBSYSTEM S_MDS
#include <obd_class.h>
#include <lustre_param.h>
+#include <lustre_log.h>
+#include <lustre_mdc.h>
#include "osp_internal.h"
/* Slab for OSP object allocation */
-cfs_mem_cache_t *osp_object_kmem;
+struct kmem_cache *osp_object_kmem;
static struct lu_kmem_descr osp_caches[] = {
{
const struct lu_object_header *hdr,
struct lu_device *d)
{
- struct lu_object_header *h;
+ struct lu_object_header *h = NULL;
struct osp_object *o;
struct lu_object *l;
- LASSERT(hdr == NULL);
-
- OBD_SLAB_ALLOC_PTR_GFP(o, osp_object_kmem, CFS_ALLOC_IO);
+ OBD_SLAB_ALLOC_PTR_GFP(o, osp_object_kmem, __GFP_IO);
if (o != NULL) {
l = &o->opo_obj.do_lu;
- h = &o->opo_header;
- lu_object_header_init(h);
- dt_object_init(&o->opo_obj, h, d);
- lu_object_add_top(h, l);
+ /* For data object, OSP obj would always be the top
+ * object, i.e. hdr is always NULL, see lu_object_alloc.
+ * But for metadata object, we always build the object
+ * stack from MDT. i.e. mdt_object will be the top object
+ * i.e. hdr != NULL */
+ if (hdr == NULL) {
+ /* object for OST */
+ h = &o->opo_header;
+ lu_object_header_init(h);
+ dt_object_init(&o->opo_obj, h, d);
+ lu_object_add_top(h, l);
+ } else {
+ dt_object_init(&o->opo_obj, h, d);
+ }
l->lo_ops = &osp_lu_obj_ops;
}
}
-/* Update opd_last_used_id along with checking for gap in objid sequence */
-void osp_update_last_id(struct osp_device *d, obd_id objid)
+static struct dt_object
+*osp_find_or_create(const struct lu_env *env, struct osp_device *osp,
+ struct lu_attr *attr, __u32 reg_id)
{
- /*
- * we might have lost precreated objects due to VBR and precreate
- * orphans, the gap in objid can be calculated properly only here
- */
- if (objid > le64_to_cpu(d->opd_last_used_id)) {
- if (objid - le64_to_cpu(d->opd_last_used_id) > 1) {
- d->opd_gap_start = le64_to_cpu(d->opd_last_used_id) + 1;
- d->opd_gap_count = objid - d->opd_gap_start;
- CDEBUG(D_HA, "Gap in objids: %d, start = %llu\n",
- d->opd_gap_count, d->opd_gap_start);
- }
- d->opd_last_used_id = cpu_to_le64(objid);
+ struct osp_thread_info *osi = osp_env_info(env);
+ struct dt_object_format dof = { 0 };
+ struct dt_object *dto;
+ int rc;
+ ENTRY;
+
+ lu_local_obj_fid(&osi->osi_fid, reg_id);
+ attr->la_valid = LA_MODE;
+ attr->la_mode = S_IFREG | 0644;
+ dof.dof_type = DFT_REGULAR;
+ dto = dt_find_or_create(env, osp->opd_storage, &osi->osi_fid,
+ &dof, attr);
+ if (IS_ERR(dto))
+ RETURN(dto);
+
+ rc = dt_attr_get(env, dto, attr, NULL);
+ if (rc) {
+ CERROR("%s: can't be initialized: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
+ lu_object_put(env, &dto->do_lu);
+ RETURN(ERR_PTR(rc));
}
+ RETURN(dto);
}
-static int osp_last_used_init(const struct lu_env *env, struct osp_device *m)
+static int osp_write_local_file(const struct lu_env *env,
+ struct osp_device *osp,
+ struct dt_object *dt_obj,
+ struct lu_buf *buf,
+ loff_t offset)
{
- struct osp_thread_info *osi = osp_env_info(env);
- struct dt_object_format dof = { 0 };
- struct dt_object *o;
- int rc;
-
- ENTRY;
+ struct thandle *th;
+ int rc;
- osi->osi_attr.la_valid = LA_MODE;
- osi->osi_attr.la_mode = S_IFREG | 0644;
- lu_local_obj_fid(&osi->osi_fid, MDD_LOV_OBJ_OID);
- dof.dof_type = DFT_REGULAR;
- o = dt_find_or_create(env, m->opd_storage, &osi->osi_fid, &dof,
- &osi->osi_attr);
- if (IS_ERR(o))
- RETURN(PTR_ERR(o));
+ th = dt_trans_create(env, osp->opd_storage);
+ if (IS_ERR(th))
+ RETURN(PTR_ERR(th));
- rc = dt_attr_get(env, o, &osi->osi_attr, NULL);
+ rc = dt_declare_record_write(env, dt_obj, buf->lb_len, offset, th);
+ if (rc)
+ GOTO(out, rc);
+ rc = dt_trans_start_local(env, osp->opd_storage, th);
if (rc)
GOTO(out, rc);
- /* object will be released in device cleanup path */
- m->opd_last_used_file = o;
+ rc = dt_record_write(env, dt_obj, buf, &offset, th);
+out:
+ dt_trans_stop(env, osp->opd_storage, th);
+ RETURN(rc);
+}
+
+static int osp_init_last_objid(const struct lu_env *env, struct osp_device *osp)
+{
+ struct osp_thread_info *osi = osp_env_info(env);
+ struct lu_fid *fid = &osp->opd_last_used_fid;
+ struct dt_object *dto;
+ int rc;
+ ENTRY;
- if (osi->osi_attr.la_size >= sizeof(osi->osi_id) *
- (m->opd_index + 1)) {
- osp_objid_buf_prep(osi, m, m->opd_index);
- rc = dt_record_read(env, o, &osi->osi_lb, &osi->osi_off);
+ dto = osp_find_or_create(env, osp, &osi->osi_attr, MDD_LOV_OBJ_OID);
+ if (IS_ERR(dto))
+ RETURN(PTR_ERR(dto));
+ /* object will be released in device cleanup path */
+ if (osi->osi_attr.la_size >=
+ sizeof(osi->osi_id) * (osp->opd_index + 1)) {
+ osp_objid_buf_prep(&osi->osi_lb, &osi->osi_off, &fid->f_oid,
+ osp->opd_index);
+ rc = dt_record_read(env, dto, &osi->osi_lb, &osi->osi_off);
if (rc != 0)
GOTO(out, rc);
} else {
- /* reset value to 0, just to make sure and change file's size */
- struct thandle *th;
+ fid->f_oid = 0;
+ osp_objid_buf_prep(&osi->osi_lb, &osi->osi_off, &fid->f_oid,
+ osp->opd_index);
+ rc = osp_write_local_file(env, osp, dto, &osi->osi_lb,
+ osi->osi_off);
+ }
+ osp->opd_last_used_oid_file = dto;
+ RETURN(0);
+out:
+ /* object will be released in device cleanup path */
+ CERROR("%s: can't initialize lov_objid: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
+ lu_object_put(env, &dto->do_lu);
+ osp->opd_last_used_oid_file = NULL;
+ RETURN(rc);
+}
- m->opd_last_used_id = 0;
- osp_objid_buf_prep(osi, m, m->opd_index);
+static int osp_init_last_seq(const struct lu_env *env, struct osp_device *osp)
+{
+ struct osp_thread_info *osi = osp_env_info(env);
+ struct lu_fid *fid = &osp->opd_last_used_fid;
+ struct dt_object *dto;
+ int rc;
+ ENTRY;
- th = dt_trans_create(env, m->opd_storage);
- if (IS_ERR(th))
- GOTO(out, rc = PTR_ERR(th));
+ dto = osp_find_or_create(env, osp, &osi->osi_attr, MDD_LOV_OBJ_OSEQ);
+ if (IS_ERR(dto))
+ RETURN(PTR_ERR(dto));
- rc = dt_declare_record_write(env, m->opd_last_used_file,
- osi->osi_lb.lb_len, osi->osi_off,
- th);
- if (rc) {
- dt_trans_stop(env, m->opd_storage, th);
+ /* object will be released in device cleanup path */
+ if (osi->osi_attr.la_size >=
+ sizeof(osi->osi_id) * (osp->opd_index + 1)) {
+ osp_objseq_buf_prep(&osi->osi_lb, &osi->osi_off, &fid->f_seq,
+ osp->opd_index);
+ rc = dt_record_read(env, dto, &osi->osi_lb, &osi->osi_off);
+ if (rc != 0)
GOTO(out, rc);
- }
+ } else {
+ fid->f_seq = 0;
+ osp_objseq_buf_prep(&osi->osi_lb, &osi->osi_off, &fid->f_seq,
+ osp->opd_index);
+ rc = osp_write_local_file(env, osp, dto, &osi->osi_lb,
+ osi->osi_off);
+ }
+ osp->opd_last_used_seq_file = dto;
+ RETURN(0);
+out:
+ /* object will be released in device cleanup path */
+ CERROR("%s: can't initialize lov_seq: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
+ lu_object_put(env, &dto->do_lu);
+ osp->opd_last_used_seq_file = NULL;
+ RETURN(rc);
+}
+
+static int osp_last_used_init(const struct lu_env *env, struct osp_device *osp)
+{
+ struct osp_thread_info *osi = osp_env_info(env);
+ int rc;
+ ENTRY;
+
+ fid_zero(&osp->opd_last_used_fid);
+ rc = osp_init_last_objid(env, osp);
+ if (rc < 0) {
+ CERROR("%s: Can not get ids %d from old objid!\n",
+ osp->opd_obd->obd_name, rc);
+ RETURN(rc);
+ }
+
+ rc = osp_init_last_seq(env, osp);
+ if (rc < 0) {
+ CERROR("%s: Can not get ids %d from old objid!\n",
+ osp->opd_obd->obd_name, rc);
+ GOTO(out, rc);
+ }
- rc = dt_trans_start_local(env, m->opd_storage, th);
+ if (fid_oid(&osp->opd_last_used_fid) != 0 &&
+ fid_seq(&osp->opd_last_used_fid) == 0) {
+ /* Just upgrade from the old version,
+ * set the seq to be IDIF */
+ osp->opd_last_used_fid.f_seq =
+ fid_idif_seq(fid_oid(&osp->opd_last_used_fid),
+ osp->opd_index);
+ osp_objseq_buf_prep(&osi->osi_lb, &osi->osi_off,
+ &osp->opd_last_used_fid.f_seq,
+ osp->opd_index);
+ rc = osp_write_local_file(env, osp, osp->opd_last_used_seq_file,
+ &osi->osi_lb, osi->osi_off);
if (rc) {
- dt_trans_stop(env, m->opd_storage, th);
+ CERROR("%s : Can not write seq file: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
GOTO(out, rc);
}
+ }
- rc = dt_record_write(env, m->opd_last_used_file, &osi->osi_lb,
- &osi->osi_off, th);
- dt_trans_stop(env, m->opd_storage, th);
- if (rc)
- GOTO(out, rc);
+ if (!fid_is_zero(&osp->opd_last_used_fid) &&
+ !fid_is_sane(&osp->opd_last_used_fid)) {
+ CERROR("%s: Got invalid FID "DFID"\n", osp->opd_obd->obd_name,
+ PFID(&osp->opd_last_used_fid));
+ GOTO(out, rc = -EINVAL);
}
- RETURN(0);
+
+ CDEBUG(D_INFO, "%s: Init last used fid "DFID"\n",
+ osp->opd_obd->obd_name, PFID(&osp->opd_last_used_fid));
out:
- CERROR("%s: can't initialize lov_objid: %d\n",
- m->opd_obd->obd_name, rc);
- lu_object_put(env, &o->do_lu);
- m->opd_last_used_file = NULL;
- return rc;
+ if (rc != 0) {
+ if (osp->opd_last_used_oid_file != NULL) {
+ lu_object_put(env, &osp->opd_last_used_oid_file->do_lu);
+ osp->opd_last_used_oid_file = NULL;
+ }
+ if (osp->opd_last_used_seq_file != NULL) {
+ lu_object_put(env, &osp->opd_last_used_seq_file->do_lu);
+ osp->opd_last_used_seq_file = NULL;
+ }
+ }
+
+ RETURN(rc);
}
static void osp_last_used_fini(const struct lu_env *env, struct osp_device *d)
{
- if (d->opd_last_used_file != NULL) {
- lu_object_put(env, &d->opd_last_used_file->do_lu);
- d->opd_last_used_file = NULL;
+ /* release last_used file */
+ if (d->opd_last_used_oid_file != NULL) {
+ lu_object_put(env, &d->opd_last_used_oid_file->do_lu);
+ d->opd_last_used_oid_file = NULL;
+ }
+
+ if (d->opd_last_used_seq_file != NULL) {
+ lu_object_put(env, &d->opd_last_used_seq_file->do_lu);
+ d->opd_last_used_seq_file = NULL;
}
}
-int osp_disconnect(struct osp_device *d)
+static int osp_disconnect(struct osp_device *d)
{
struct obd_import *imp;
int rc = 0;
* of the cleanup RPCs fails (e.g. ldlm cancel, etc). We don't
* fully deactivate the import, or that would drop all requests. */
LASSERT(imp != NULL);
- cfs_spin_lock(&imp->imp_lock);
+ spin_lock(&imp->imp_lock);
imp->imp_deactive = 1;
- cfs_spin_unlock(&imp->imp_lock);
+ spin_unlock(&imp->imp_lock);
ptlrpc_deactivate_import(imp);
(void)ptlrpc_pinger_del_import(imp);
rc = ptlrpc_disconnect_import(imp, 0);
- if (rc && rc != -ETIMEDOUT)
+ if (rc == -ETIMEDOUT || rc == -ENOTCONN || rc == -ESHUTDOWN)
+ rc = 0;
+ if (rc)
CERROR("%s: can't disconnect: rc = %d\n",
d->opd_obd->obd_name, rc);
int rc = 0;
ENTRY;
- if (is_osp_on_ost(d->opd_obd->obd_name)) {
- rc = osp_disconnect(d);
- RETURN(rc);
- }
-
LASSERT(env);
- /* release last_used file */
- osp_last_used_fini(env, d);
rc = osp_disconnect(d);
- /* stop precreate thread */
- osp_precreate_fini(d);
+ if (!d->opd_connect_mdt) {
+ /* stop precreate thread */
+ osp_precreate_fini(d);
+
+ /* stop sync thread */
+ osp_sync_fini(d);
- /* stop sync thread */
- osp_sync_fini(d);
+ /* release last_used file */
+ osp_last_used_fini(env, d);
+ }
+
+ obd_fid_fini(d->opd_obd);
RETURN(rc);
}
struct lu_device *dev, struct lustre_cfg *lcfg)
{
struct osp_device *d = lu2osp_dev(dev);
- struct lprocfs_static_vars lvars = { 0 };
+ struct obd_device *obd = d->opd_obd;
int rc;
ENTRY;
switch (lcfg->lcfg_command) {
+ case LCFG_PRE_CLEANUP:
+ rc = osp_disconnect(d);
+ break;
case LCFG_CLEANUP:
- if (!is_osp_on_ost(d->opd_obd->obd_name))
- lu_dev_del_linkage(dev->ld_site, dev);
+ lu_dev_del_linkage(dev->ld_site, dev);
rc = osp_shutdown(env, d);
break;
case LCFG_PARAM:
- lprocfs_osp_init_vars(&lvars);
-
- LASSERT(d->opd_obd);
- rc = class_process_proc_param(PARAM_OSC, lvars.obd_vars,
- lcfg, d->opd_obd);
+ LASSERT(obd);
+ rc = class_process_proc_seq_param(PARAM_OSC, obd->obd_vars,
+ lcfg, obd);
if (rc > 0)
rc = 0;
if (rc == -ENOSYS) {
ENTRY;
osp->opd_recovery_completed = 1;
- cfs_waitq_signal(&osp->opd_pre_waitq);
+
+ if (!osp->opd_connect_mdt && osp->opd_pre != NULL)
+ wake_up(&osp->opd_pre_waitq);
RETURN(rc);
}
if (unlikely(d->opd_imp_active == 0))
RETURN(-ENOTCONN);
+ if (d->opd_pre == NULL)
+ RETURN(0);
+
/* return recently updated data */
*sfs = d->opd_statfs;
* layer above osp (usually lod) can use ffree to estimate
* how many objects are available for immediate creation
*/
- cfs_spin_lock(&d->opd_pre_lock);
- sfs->os_fprecreated = d->opd_pre_last_created - d->opd_pre_used_id;
+ spin_lock(&d->opd_pre_lock);
+ LASSERTF(fid_seq(&d->opd_pre_last_created_fid) ==
+ fid_seq(&d->opd_pre_used_fid),
+ "last_created "DFID", next_fid "DFID"\n",
+ PFID(&d->opd_pre_last_created_fid),
+ PFID(&d->opd_pre_used_fid));
+ sfs->os_fprecreated = fid_oid(&d->opd_pre_last_created_fid) -
+ fid_oid(&d->opd_pre_used_fid);
sfs->os_fprecreated -= d->opd_pre_reserved;
- cfs_spin_unlock(&d->opd_pre_lock);
+ spin_unlock(&d->opd_pre_lock);
- LASSERT(sfs->os_fprecreated <= OST_MAX_PRECREATE);
+ LASSERT(sfs->os_fprecreated <= OST_MAX_PRECREATE * 2);
CDEBUG(D_OTHER, "%s: "LPU64" blocks, "LPU64" free, "LPU64" avail, "
LPU64" files, "LPU64" free files\n", d->opd_obd->obd_name,
const struct dt_device_operations osp_dt_ops = {
.dt_statfs = osp_statfs,
.dt_sync = osp_sync,
+ .dt_trans_start = osp_trans_start,
+ .dt_trans_stop = osp_trans_stop,
};
static int osp_connect_to_osd(const struct lu_env *env, struct osp_device *m,
static int osp_init0(const struct lu_env *env, struct osp_device *m,
struct lu_device_type *ldt, struct lustre_cfg *cfg)
{
- struct obd_device *obd;
- struct obd_import *imp;
- class_uuid_t uuid;
- char *src, *ost, *mdt, *osdname = NULL;
- int rc, idx;
+ struct obd_device *obd;
+ struct obd_import *imp;
+ class_uuid_t uuid;
+ char *src, *tgt, *mdt, *osdname = NULL;
+ int rc;
+ long idx;
ENTRY;
if (src == NULL)
RETURN(-EINVAL);
- ost = strstr(src, "-OST");
- if (ost == NULL)
+ tgt = strrchr(src, '-');
+ if (tgt == NULL) {
+ CERROR("%s: invalid target name %s\n",
+ m->opd_obd->obd_name, lustre_cfg_string(cfg, 0));
RETURN(-EINVAL);
-
- idx = simple_strtol(ost + 4, &mdt, 16);
- if (mdt[0] != '-' || idx > INT_MAX || idx < 0) {
- CERROR("%s: invalid OST index in '%s'\n", obd->obd_name, src);
- GOTO(out_fini, rc = -EINVAL);
}
- m->opd_index = idx;
- idx = ost - src;
+ if (strncmp(tgt, "-osc", 4) == 0) {
+ /* Old OSC name fsname-OSTXXXX-osc */
+ for (tgt--; tgt > src && *tgt != '-'; tgt--)
+ ;
+ if (tgt == src) {
+ CERROR("%s: invalid target name %s\n",
+ m->opd_obd->obd_name, lustre_cfg_string(cfg, 0));
+ RETURN(-EINVAL);
+ }
+
+ if (strncmp(tgt, "-OST", 4) != 0) {
+ CERROR("%s: invalid target name %s\n",
+ m->opd_obd->obd_name, lustre_cfg_string(cfg, 0));
+ RETURN(-EINVAL);
+ }
+
+ idx = simple_strtol(tgt + 4, &mdt, 16);
+ if (mdt[0] != '-' || idx > INT_MAX || idx < 0) {
+ CERROR("%s: invalid OST index in '%s'\n",
+ m->opd_obd->obd_name, src);
+ RETURN(-EINVAL);
+ }
+ m->opd_index = idx;
+ m->opd_group = 0;
+ idx = tgt - src;
+ } else {
+ /* New OSC name fsname-OSTXXXX-osc-MDTXXXX */
+ if (strncmp(tgt, "-MDT", 4) != 0 &&
+ strncmp(tgt, "-OST", 4) != 0) {
+ CERROR("%s: invalid target name %s\n",
+ m->opd_obd->obd_name, lustre_cfg_string(cfg, 0));
+ RETURN(-EINVAL);
+ }
+
+ idx = simple_strtol(tgt + 4, &mdt, 16);
+ if (*mdt != '\0' || idx > INT_MAX || idx < 0) {
+ CERROR("%s: invalid OST index in '%s'\n",
+ m->opd_obd->obd_name, src);
+ RETURN(-EINVAL);
+ }
+
+ /* Get MDT index from the name and set it to opd_group,
+ * which will be used by OSP to connect with OST */
+ m->opd_group = idx;
+ if (tgt - src <= 12) {
+ CERROR("%s: invalid mdt index retrieve from %s\n",
+ m->opd_obd->obd_name, lustre_cfg_string(cfg, 0));
+ RETURN(-EINVAL);
+ }
+
+ if (strncmp(tgt - 12, "-MDT", 4) == 0)
+ m->opd_connect_mdt = 1;
+
+ idx = simple_strtol(tgt - 8, &mdt, 16);
+ if (mdt[0] != '-' || idx > INT_MAX || idx < 0) {
+ CERROR("%s: invalid OST index in '%s'\n",
+ m->opd_obd->obd_name, src);
+ RETURN(-EINVAL);
+ }
+
+ m->opd_index = idx;
+ idx = tgt - src - 12;
+ }
/* check the fsname length, and after this everything else will fit */
if (idx > MTI_NAME_MAXLEN) {
- CERROR("%s: fsname too long in '%s'\n", obd->obd_name, src);
- GOTO(out_fini, rc = -EINVAL);
+ CERROR("%s: fsname too long in '%s'\n",
+ m->opd_obd->obd_name, src);
+ RETURN(-EINVAL);
}
OBD_ALLOC(osdname, MAX_OBD_NAME);
if (osdname == NULL)
- GOTO(out_fini, rc = -ENOMEM);
+ RETURN(-ENOMEM);
memcpy(osdname, src, idx); /* copy just the fsname part */
osdname[idx] = '\0';
strcat(osdname, "-osd");
CDEBUG(D_HA, "%s: connect to %s (%s)\n", obd->obd_name, osdname, src);
+ if (m->opd_connect_mdt) {
+ struct client_obd *cli = &m->opd_obd->u.cli;
+
+ OBD_ALLOC(cli->cl_rpc_lock, sizeof(*cli->cl_rpc_lock));
+ if (!cli->cl_rpc_lock)
+ GOTO(out_fini, rc = -ENOMEM);
+ osp_init_rpc_lock(cli->cl_rpc_lock);
+ }
+
m->opd_dt_dev.dd_lu_dev.ld_ops = &osp_lu_ops;
m->opd_dt_dev.dd_ops = &osp_dt_ops;
obd->obd_lu_dev = &m->opd_dt_dev.dd_lu_dev;
osp_lprocfs_init(m);
- /*
- * Initialize last id from the storage - will be used in orphan cleanup
- */
- rc = osp_last_used_init(env, m);
- if (rc)
+ rc = obd_fid_init(m->opd_obd, NULL, m->opd_connect_mdt ?
+ LUSTRE_SEQ_METADATA : LUSTRE_SEQ_DATA);
+ if (rc) {
+ CERROR("%s: fid init error: rc = %d\n",
+ m->opd_obd->obd_name, rc);
GOTO(out_proc, rc);
+ }
- /*
- * Initialize precreation thread, it handles new connections as well
- */
- rc = osp_init_precreate(m);
- if (rc)
- GOTO(out_last_used, rc);
+ if (!m->opd_connect_mdt) {
+ /* Initialize last id from the storage - will be
+ * used in orphan cleanup. */
+ rc = osp_last_used_init(env, m);
+ if (rc)
+ GOTO(out_proc, rc);
- /*
- * Initialize synhronization mechanism taking care of propogating
- * changes to OST in near transactional manner
- */
- rc = osp_sync_init(env, m);
- if (rc)
- GOTO(out_precreat, rc);
+
+ /* Initialize precreation thread, it handles new
+ * connections as well. */
+ rc = osp_init_precreate(m);
+ if (rc)
+ GOTO(out_last_used, rc);
+ /*
+ * Initialize synhronization mechanism taking
+ * care of propogating changes to OST in near
+ * transactional manner.
+ */
+ rc = osp_sync_init(env, m);
+ if (rc)
+ GOTO(out_precreat, rc);
+ }
/*
* Initiate connect to OST
RETURN(0);
out:
- /* stop sync thread */
- osp_sync_fini(m);
+ if (!m->opd_connect_mdt)
+ /* stop sync thread */
+ osp_sync_fini(m);
out_precreat:
/* stop precreate thread */
- osp_precreate_fini(m);
+ if (!m->opd_connect_mdt)
+ osp_precreate_fini(m);
out_last_used:
- osp_last_used_fini(env, m);
+ if (!m->opd_connect_mdt)
+ osp_last_used_fini(env, m);
out_proc:
ptlrpc_lprocfs_unregister_obd(obd);
lprocfs_obd_cleanup(obd);
- class_destroy_import(obd->u.cli.cl_import);
+ if (m->opd_symlink)
+ lprocfs_remove(&m->opd_symlink);
client_obd_cleanup(obd);
out_ref:
ptlrpcd_decref();
out_disconnect:
+ if (m->opd_connect_mdt) {
+ struct client_obd *cli = &m->opd_obd->u.cli;
+ if (cli->cl_rpc_lock != NULL) {
+ OBD_FREE_PTR(cli->cl_rpc_lock);
+ cli->cl_rpc_lock = NULL;
+ }
+ }
obd_disconnect(m->opd_storage_exp);
out_fini:
if (osdname)
l = osp2lu_dev(m);
dt_device_init(&m->opd_dt_dev, t);
- if (is_osp_on_ost(lustre_cfg_string(lcfg, 0)))
- rc = osp_init_for_ost(env, m, t, lcfg);
- else
- rc = osp_init0(env, m, t, lcfg);
+ rc = osp_init0(env, m, t, lcfg);
if (rc != 0) {
osp_device_free(env, l);
l = ERR_PTR(rc);
if (m->opd_storage_exp)
obd_disconnect(m->opd_storage_exp);
- if (is_osp_on_ost(m->opd_obd->obd_name))
- osp_fini_for_ost(m);
-
imp = m->opd_obd->u.cli.cl_import;
if (imp->imp_rq_pool) {
imp->imp_rq_pool = NULL;
}
- obd_cleanup_client_import(m->opd_obd);
-
if (m->opd_symlink)
lprocfs_remove(&m->opd_symlink);
ptlrpc_lprocfs_unregister_obd(m->opd_obd);
lprocfs_obd_cleanup(m->opd_obd);
+ if (m->opd_connect_mdt) {
+ struct client_obd *cli = &m->opd_obd->u.cli;
+ if (cli->cl_rpc_lock != NULL) {
+ OBD_FREE_PTR(cli->cl_rpc_lock);
+ cli->cl_rpc_lock = NULL;
+ }
+ } else {
+ if (m->opd_obd->obd_proc_private != NULL)
+ lprocfs_remove((struct proc_dir_entry **)&m->opd_obd->obd_proc_private);
+ }
+
rc = client_obd_cleanup(m->opd_obd);
LASSERTF(rc == 0, "error %d\n", rc);
return 0;
}
+static int osp_prepare_fid_client(struct osp_device *osp)
+{
+ int rc;
+
+ LASSERT(osp->opd_obd->u.cli.cl_seq != NULL);
+ if (osp->opd_obd->u.cli.cl_seq->lcs_exp != NULL)
+ return 0;
+
+ LASSERT(osp->opd_exp != NULL);
+ osp->opd_obd->u.cli.cl_seq->lcs_exp =
+ class_export_get(osp->opd_exp);
+ if (osp->opd_pre == NULL)
+ return 0;
+
+ /* Init fid for osp_precreate if necessary */
+ rc = osp_init_pre_fid(osp);
+ if (rc != 0) {
+ class_export_put(osp->opd_exp);
+ osp->opd_obd->u.cli.cl_seq->lcs_exp = NULL;
+ CERROR("%s: init pre fid error: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
+ return rc;
+ }
+
+ return 0;
+}
+
/*
* we use exports to track all LOD users
*/
RETURN(rc);
*exp = class_conn2export(&conn);
- if (is_osp_on_ost(obd->obd_name))
- osp->opd_exp = *exp;
-
/* Why should there ever be more than 1 connect? */
osp->opd_connects++;
LASSERT(osp->opd_connects == 1);
+ osp->opd_exp = *exp;
+
imp = osp->opd_obd->u.cli.cl_import;
imp->imp_dlm_handle = conn;
+ LASSERT(data != NULL);
+ LASSERT(data->ocd_connect_flags & OBD_CONNECT_INDEX);
ocd = &imp->imp_connect_data;
- ocd->ocd_connect_flags = OBD_CONNECT_AT |
- OBD_CONNECT_FULL20 |
- OBD_CONNECT_INDEX |
-#ifdef HAVE_LRU_RESIZE_SUPPORT
- OBD_CONNECT_LRU_RESIZE |
-#endif
- OBD_CONNECT_MDS |
- OBD_CONNECT_OSS_CAPA |
- OBD_CONNECT_REQPORTAL |
- OBD_CONNECT_SKIP_ORPHAN |
- OBD_CONNECT_VERSION |
- OBD_CONNECT_FID;
+ *ocd = *data;
- if (is_osp_on_ost(osp->opd_obd->obd_name))
- ocd->ocd_connect_flags |= OBD_CONNECT_LIGHTWEIGHT;
+ imp->imp_connect_flags_orig = ocd->ocd_connect_flags;
ocd->ocd_version = LUSTRE_VERSION_CODE;
- LASSERT(data->ocd_connect_flags & OBD_CONNECT_INDEX);
ocd->ocd_index = data->ocd_index;
imp->imp_connect_flags_orig = ocd->ocd_connect_flags;
}
ptlrpc_pinger_add_import(imp);
-
out:
RETURN(rc);
}
}
/* destroy the device */
- if (!is_osp_on_ost(obd->obd_name))
- class_manual_cleanup(obd);
+ class_manual_cleanup(obd);
RETURN(rc);
}
/* Since the request might also come from lprocfs, so we need
* sync this with client_disconnect_export Bug15684 */
- cfs_down_read(&exp->exp_obd->u.cli.cl_sem);
+ down_read(&exp->exp_obd->u.cli.cl_sem);
if (exp->exp_obd->u.cli.cl_import)
imp = class_import_get(exp->exp_obd->u.cli.cl_import);
- cfs_up_read(&exp->exp_obd->u.cli.cl_sem);
+ up_read(&exp->exp_obd->u.cli.cl_sem);
if (!imp)
RETURN(-ENODEV);
case IMP_EVENT_DISCON:
d->opd_got_disconnected = 1;
d->opd_imp_connected = 0;
- if (is_osp_on_ost(d->opd_obd->obd_name))
+ if (d->opd_connect_mdt)
break;
- osp_pre_update_status(d, -ENODEV);
- cfs_waitq_signal(&d->opd_pre_waitq);
+
+ if (d->opd_pre != NULL) {
+ osp_pre_update_status(d, -ENODEV);
+ wake_up(&d->opd_pre_waitq);
+ }
+
CDEBUG(D_HA, "got disconnected\n");
break;
case IMP_EVENT_INACTIVE:
d->opd_imp_active = 0;
- if (is_osp_on_ost(d->opd_obd->obd_name))
+ if (d->opd_connect_mdt)
break;
- osp_pre_update_status(d, -ENODEV);
- cfs_waitq_signal(&d->opd_pre_waitq);
+
+ if (d->opd_pre != NULL) {
+ osp_pre_update_status(d, -ENODEV);
+ wake_up(&d->opd_pre_waitq);
+ }
+
CDEBUG(D_HA, "got inactive\n");
break;
case IMP_EVENT_ACTIVE:
d->opd_imp_active = 1;
+
+ if (osp_prepare_fid_client(d) != 0)
+ break;
+
if (d->opd_got_disconnected)
d->opd_new_connection = 1;
d->opd_imp_connected = 1;
d->opd_imp_seen_connected = 1;
- if (is_osp_on_ost(d->opd_obd->obd_name))
+ if (d->opd_connect_mdt)
break;
- cfs_waitq_signal(&d->opd_pre_waitq);
+
+ if (d->opd_pre != NULL)
+ wake_up(&d->opd_pre_waitq);
+
__osp_sync_check_for_work(d);
CDEBUG(D_HA, "got connected\n");
break;
ldlm_namespace_cleanup(obd->obd_namespace, LDLM_FL_LOCAL_ONLY);
break;
case IMP_EVENT_OCD:
+ case IMP_EVENT_DEACTIVATE:
+ case IMP_EVENT_ACTIVATE:
break;
default:
CERROR("%s: unsupported import event: %#x\n",
d = lu2osp_dev(obd->obd_lu_dev);
LASSERT(d->opd_dt_dev.dd_ops == &osp_dt_ops);
- if (!cfs_try_module_get(THIS_MODULE)) {
+ if (!try_module_get(THIS_MODULE)) {
CERROR("%s: can't get module. Is it alive?", obd->obd_name);
return -EINVAL;
}
break;
default:
CERROR("%s: unrecognized ioctl %#x by %s\n", obd->obd_name,
- cmd, cfs_curproc_comm());
+ cmd, current_comm());
rc = -ENOTTY;
}
- cfs_module_put(THIS_MODULE);
+ module_put(THIS_MODULE);
return rc;
}
-static int osp_obd_health_check(const struct lu_env *env,
- struct obd_device *obd)
+static int osp_obd_get_info(const struct lu_env *env, struct obd_export *exp,
+ __u32 keylen, void *key, __u32 *vallen, void *val,
+ struct lov_stripe_md *lsm)
{
- struct osp_device *d = lu2osp_dev(obd->obd_lu_dev);
-
- ENTRY;
+ int rc = -EINVAL;
+
+ if (KEY_IS(KEY_OSP_CONNECTED)) {
+ struct obd_device *obd = exp->exp_obd;
+ struct osp_device *osp;
+
+ if (!obd->obd_set_up || obd->obd_stopping)
+ RETURN(-EAGAIN);
+
+ osp = lu2osp_dev(obd->obd_lu_dev);
+ LASSERT(osp);
+ /*
+ * 1.8/2.0 behaviour is that OST being connected once at least
+ * is considered "healthy". and one "healthy" OST is enough to
+ * allow lustre clients to connect to MDS
+ */
+ RETURN(!osp->opd_imp_seen_connected);
+ }
- /*
- * 1.8/2.0 behaviour is that OST being connected once at least
- * is considired "healthy". and one "healty" OST is enough to
- * allow lustre clients to connect to MDS
- */
- LASSERT(d);
- RETURN(!d->opd_imp_seen_connected);
+ RETURN(rc);
}
/* context key constructor/destructor: mdt_key_init, mdt_key_fini */
.o_reconnect = osp_reconnect,
.o_connect = osp_obd_connect,
.o_disconnect = osp_obd_disconnect,
- .o_health_check = osp_obd_health_check,
+ .o_get_info = osp_obd_get_info,
.o_import_event = osp_import_event,
.o_iocontrol = osp_iocontrol,
.o_statfs = osp_obd_statfs,
+ .o_fid_init = client_fid_init,
+ .o_fid_fini = client_fid_fini,
};
+struct llog_operations osp_mds_ost_orig_logops;
+
static int __init osp_mod_init(void)
{
- struct lprocfs_static_vars lvars;
- cfs_proc_dir_entry_t *osc_proc_dir;
- int rc;
+ int rc;
rc = lu_kmem_init(osp_caches);
if (rc)
return rc;
- lprocfs_osp_init_vars(&lvars);
-
- rc = class_register_type(&osp_obd_device_ops, NULL, lvars.module_vars,
- LUSTRE_OSP_NAME, &osp_device_type);
-
- /* create "osc" entry in procfs for compatibility purposes */
+ rc = class_register_type(&osp_obd_device_ops, NULL, NULL,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+ NULL,
+#endif
+ LUSTRE_OSP_NAME, &osp_device_type);
if (rc != 0) {
lu_kmem_fini(osp_caches);
return rc;
}
- osc_proc_dir = lprocfs_srch(proc_lustre_root, "osc");
- if (osc_proc_dir == NULL) {
- osc_proc_dir = lprocfs_register("osc", proc_lustre_root, NULL,
- NULL);
- if (IS_ERR(osc_proc_dir))
- CERROR("osp: can't create compat entry \"osc\": %d\n",
- (int) PTR_ERR(osc_proc_dir));
+ rc = class_register_type(&lwp_obd_device_ops, NULL, NULL,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+ NULL,
+#endif
+ LUSTRE_LWP_NAME, &lwp_device_type);
+ if (rc != 0) {
+ class_unregister_type(LUSTRE_OSP_NAME);
+ lu_kmem_fini(osp_caches);
+ return rc;
}
+
+ /* Note: add_rec/delcare_add_rec will be only used by catalogs */
+ osp_mds_ost_orig_logops = llog_osd_ops;
+ osp_mds_ost_orig_logops.lop_add = llog_cat_add_rec;
+ osp_mds_ost_orig_logops.lop_declare_add = llog_cat_declare_add_rec;
return rc;
}
static void __exit osp_mod_exit(void)
{
- lprocfs_try_remove_proc_entry("osc", proc_lustre_root);
-
+ class_unregister_type(LUSTRE_LWP_NAME);
class_unregister_type(LUSTRE_OSP_NAME);
lu_kmem_fini(osp_caches);
}