#define DEBUG_SUBSYSTEM S_MDS
#include <obd_class.h>
+#include <lustre_ioctl.h>
#include <lustre_param.h>
#include <lustre_log.h>
#include <lustre_mdc.h>
struct osp_object *o;
struct lu_object *l;
- OBD_SLAB_ALLOC_PTR_GFP(o, osp_object_kmem, __GFP_IO);
+ OBD_SLAB_ALLOC_PTR_GFP(o, osp_object_kmem, GFP_NOFS);
if (o != NULL) {
l = &o->opo_obj.do_lu;
- /* 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 is NULL, it means the object is not built
+ * from the top dev(MDT/OST), usually it happens when
+ * building striped object, like data object on MDT or
+ * striped object for directory */
if (hdr == NULL) {
- /* object for OST */
h = &o->opo_header;
lu_object_header_init(h);
dt_object_init(&o->opo_obj, h, d);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
- rc = dt_declare_record_write(env, dt_obj, buf->lb_len, offset, th);
+ rc = dt_declare_record_write(env, dt_obj, buf, offset, th);
if (rc)
GOTO(out, rc);
rc = dt_trans_start_local(env, osp->opd_storage, th);
(void)ptlrpc_pinger_del_import(imp);
rc = ptlrpc_disconnect_import(imp, 0);
- if (rc == -ETIMEDOUT || rc == -ENOTCONN || rc == -ESHUTDOWN)
- rc = 0;
- if (rc)
+ if (rc != 0)
CERROR("%s: can't disconnect: rc = %d\n",
d->opd_obd->obd_name, rc);
rc = osp_disconnect(d);
+ osp_sync_fini(d);
+
if (!d->opd_connect_mdt) {
/* stop precreate thread */
osp_precreate_fini(d);
- /* stop sync thread */
- osp_sync_fini(d);
-
/* release last_used file */
osp_last_used_fini(env, d);
}
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;
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;
- if (!osp->opd_connect_mdt)
+
+ 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
*/
-
spin_lock(&d->opd_pre_lock);
LASSERTF(fid_seq(&d->opd_pre_last_created_fid) ==
fid_seq(&d->opd_pre_used_fid),
RETURN(0);
}
+static int osp_sync_timeout(void *data)
+{
+ return 1;
+}
+
static int osp_sync(const struct lu_env *env, struct dt_device *dev)
{
+ struct osp_device *d = dt2osp_dev(dev);
+ cfs_time_t expire;
+ struct l_wait_info lwi = { 0 };
+ unsigned long id, old;
+ int rc = 0;
+ unsigned long start = cfs_time_current();
ENTRY;
- /*
- * XXX: wake up sync thread, command it to start flushing asap?
- */
+ if (unlikely(d->opd_imp_active == 0))
+ RETURN(-ENOTCONN);
- RETURN(0);
+ id = d->opd_syn_last_used_id;
+
+ CDEBUG(D_OTHER, "%s: id: used %lu, processed %lu\n",
+ d->opd_obd->obd_name, id, d->opd_syn_last_processed_id);
+
+ /* wait till all-in-line are processed */
+ while (d->opd_syn_last_processed_id < id) {
+
+ old = d->opd_syn_last_processed_id;
+
+ /* make sure the connection is fine */
+ expire = cfs_time_shift(obd_timeout);
+ lwi = LWI_TIMEOUT(expire - cfs_time_current(),
+ osp_sync_timeout, d);
+ l_wait_event(d->opd_syn_barrier_waitq,
+ d->opd_syn_last_processed_id >= id,
+ &lwi);
+
+ if (d->opd_syn_last_processed_id >= id)
+ break;
+
+ if (d->opd_syn_last_processed_id != old) {
+ /* some progress have been made,
+ * keep trying... */
+ continue;
+ }
+
+ /* no changes and expired, something is wrong */
+ GOTO(out, rc = -ETIMEDOUT);
+ }
+
+ /* block new processing (barrier>0 - few callers are possible */
+ atomic_inc(&d->opd_syn_barrier);
+
+ CDEBUG(D_OTHER, "%s: %u in flight\n", d->opd_obd->obd_name,
+ d->opd_syn_rpc_in_flight);
+
+ /* wait till all-in-flight are replied, so executed by the target */
+ /* XXX: this is used by LFSCK at the moment, which doesn't require
+ * all the changes to be committed, but in general it'd be
+ * better to wait till commit */
+ while (d->opd_syn_rpc_in_flight > 0) {
+
+ old = d->opd_syn_rpc_in_flight;
+
+ expire = cfs_time_shift(obd_timeout);
+ lwi = LWI_TIMEOUT(expire - cfs_time_current(),
+ osp_sync_timeout, d);
+ l_wait_event(d->opd_syn_barrier_waitq,
+ d->opd_syn_rpc_in_flight == 0, &lwi);
+
+ if (d->opd_syn_rpc_in_flight == 0)
+ break;
+
+ if (d->opd_syn_rpc_in_flight != old) {
+ /* some progress have been made */
+ continue;
+ }
+
+ /* no changes and expired, something is wrong */
+ GOTO(out, rc = -ETIMEDOUT);
+ }
+
+ CDEBUG(D_OTHER, "%s: done in %lu\n", d->opd_obd->obd_name,
+ cfs_time_current() - start);
+out:
+ /* resume normal processing (barrier=0) */
+ atomic_dec(&d->opd_syn_barrier);
+ __osp_sync_check_for_work(d);
+
+ RETURN(rc);
}
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,
+ .dt_statfs = osp_statfs,
+ .dt_sync = osp_sync,
+ .dt_trans_create = osp_trans_create,
+ .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,
ENTRY;
+ mutex_init(&m->opd_async_requests_mutex);
+
obd = class_name2obd(lustre_cfg_string(cfg, 0));
if (obd == NULL) {
CERROR("Cannot find obd with name %s\n",
osp_lprocfs_init(m);
+ 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);
+ }
+
if (!m->opd_connect_mdt) {
/* Initialize last id from the storage - will be
* used in orphan cleanup. */
if (rc)
GOTO(out_proc, rc);
- rc = obd_fid_init(m->opd_obd, NULL, LUSTRE_SEQ_DATA);
- if (rc) {
- CERROR("%s: fid init error: rc = %d\n",
- m->opd_obd->obd_name, rc);
- GOTO(out_last_used, 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);
-
}
+
+ /*
+ * 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:
- if (!m->opd_connect_mdt)
- /* stop sync thread */
- osp_sync_fini(m);
+ /* stop sync thread */
+ osp_sync_fini(m);
out_precreat:
/* stop precreate thread */
if (!m->opd_connect_mdt)
ENTRY;
- if (cfs_atomic_read(&lu->ld_ref) && lu->ld_site) {
+ if (atomic_read(&lu->ld_ref) && lu->ld_site) {
LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_ERROR, NULL);
lu_site_print(env, lu->ld_site, &msgdata, lu_cdebug_printer);
}
ENTRY;
+ if (m->opd_async_requests != NULL) {
+ out_destroy_update_req(m->opd_async_requests);
+ m->opd_async_requests = NULL;
+ }
+
if (m->opd_storage_exp)
obd_disconnect(m->opd_storage_exp);
return 0;
}
+static int osp_prepare_fid_client(struct osp_device *osp)
+{
+ 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);
+ return 0;
+}
+
/*
* we use exports to track all LOD users
*/
d->opd_imp_connected = 0;
if (d->opd_connect_mdt)
break;
- osp_pre_update_status(d, -ENODEV);
- wake_up(&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 (d->opd_connect_mdt)
break;
- osp_pre_update_status(d, -ENODEV);
- wake_up(&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 (d->opd_connect_mdt)
break;
- wake_up(&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;
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);
+ 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);
+ }
+
+ RETURN(rc);
+}
+
+int osp_fid_alloc(const struct lu_env *env, struct obd_export *exp,
+ struct lu_fid *fid, struct md_op_data *op_data)
+{
+ struct client_obd *cli = &exp->exp_obd->u.cli;
+ struct osp_device *osp = lu2osp_dev(exp->exp_obd->obd_lu_dev);
+ struct lu_client_seq *seq = cli->cl_seq;
ENTRY;
- /*
- * 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);
+ LASSERT(osp->opd_obd->u.cli.cl_seq != NULL);
+ /* Sigh, fid client is not ready yet */
+ if (osp->opd_obd->u.cli.cl_seq->lcs_exp == NULL)
+ RETURN(-ENOTCONN);
+
+ RETURN(seq_client_alloc_fid(env, seq, fid));
}
/* context key constructor/destructor: mdt_key_init, mdt_key_fini */
LU_KEY_INIT_FINI(osp_txn, struct osp_txn_info);
struct lu_context_key osp_txn_key = {
- .lct_tags = LCT_OSP_THREAD,
+ .lct_tags = LCT_OSP_THREAD | LCT_TX_HANDLE,
.lct_init = osp_txn_key_init,
.lct_fini = osp_txn_key_fini
};
.ldt_tags = LU_DEVICE_DT,
.ldt_name = LUSTRE_OSP_NAME,
.ldt_ops = &osp_device_type_ops,
- .ldt_ctx_tags = LCT_MD_THREAD
+ .ldt_ctx_tags = LCT_MD_THREAD | LCT_DT_THREAD,
};
static struct obd_ops osp_obd_device_ops = {
.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,
+ .o_fid_alloc = osp_fid_alloc,
};
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;
+ struct obd_type *type;
+ 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, NULL,
+ rc = class_register_type(&osp_obd_device_ops, NULL, true, NULL,
#ifndef HAVE_ONLY_PROCFS_SEQ
- lvars.module_vars,
+ NULL,
#endif
- LUSTRE_OSP_NAME, &osp_device_type);
-
- /* create "osc" entry in procfs for compatibility purposes */
+ LUSTRE_OSP_NAME, &osp_device_type);
if (rc != 0) {
lu_kmem_fini(osp_caches);
return rc;
}
- lprocfs_lwp_init_vars(&lvars);
-
- rc = class_register_type(&lwp_obd_device_ops, NULL, NULL,
+ rc = class_register_type(&lwp_obd_device_ops, NULL, true, NULL,
#ifndef HAVE_ONLY_PROCFS_SEQ
- lvars.module_vars,
+ NULL,
#endif
- LUSTRE_LWP_NAME, &lwp_device_type);
+ LUSTRE_LWP_NAME, &lwp_device_type);
if (rc != 0) {
class_unregister_type(LUSTRE_OSP_NAME);
lu_kmem_fini(osp_caches);
osp_mds_ost_orig_logops.lop_add = llog_cat_add_rec;
osp_mds_ost_orig_logops.lop_declare_add = llog_cat_declare_add_rec;
- 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));
+ /* create "osc" entry in procfs for compatibility purposes */
+ type = class_search_type(LUSTRE_OSC_NAME);
+ if (type != NULL && type->typ_procroot != NULL)
+ return rc;
+
+ type = class_search_type(LUSTRE_OSP_NAME);
+ type->typ_procsym = lprocfs_seq_register("osc", proc_lustre_root,
+ NULL, NULL);
+ if (IS_ERR(type->typ_procsym)) {
+ CERROR("osp: can't create compat entry \"osc\": %d\n",
+ (int) PTR_ERR(type->typ_procsym));
+ type->typ_procsym = NULL;
}
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);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff