CDEBUG(D_INFO, "%s: Attached sequence controller %s\n",
seq->lss_name, cli->lcs_name);
- seq->lss_cli = cli;
- cli->lcs_space.lsr_index = seq->lss_site->ms_node_id;
- EXIT;
+ seq->lss_cli = cli;
+ cli->lcs_space.lsr_index = seq->lss_site->ss_node_id;
+ EXIT;
out_up:
mutex_unlock(&seq->lss_mutex);
return rc;
if (range_is_exhausted(loset)) {
/* reached high water mark. */
- struct lu_device *dev = seq->lss_site->ms_lu->ls_top_dev;
+ struct lu_device *dev = seq->lss_site->ss_lu->ls_top_dev;
int obd_num_clients = dev->ld_obd->obd_num_exports;
__u64 set_sz;
const struct lu_env *env,
__u32 opc, struct lu_seq_range *out)
{
- int rc;
- struct md_site *mite;
- ENTRY;
+ int rc;
+ struct seq_server_site *ss_site;
+ ENTRY;
- mite = lu_site2md(site);
- switch (opc) {
- case SEQ_ALLOC_META:
- if (!mite->ms_server_seq) {
- CERROR("Sequence server is not "
- "initialized\n");
- RETURN(-EINVAL);
- }
- rc = seq_server_alloc_meta(mite->ms_server_seq, out, env);
- break;
- case SEQ_ALLOC_SUPER:
- if (!mite->ms_control_seq) {
- CERROR("Sequence controller is not "
- "initialized\n");
- RETURN(-EINVAL);
- }
- rc = seq_server_alloc_super(mite->ms_control_seq, out, env);
- break;
- default:
- rc = -EINVAL;
- break;
- }
+ ss_site = lu_site2seq(site);
+ switch (opc) {
+ case SEQ_ALLOC_META:
+ if (!ss_site->ss_server_seq) {
+ CERROR("Sequence server is not "
+ "initialized\n");
+ RETURN(-EINVAL);
+ }
+ rc = seq_server_alloc_meta(ss_site->ss_server_seq, out, env);
+ break;
+ case SEQ_ALLOC_SUPER:
+ if (!ss_site->ss_control_seq) {
+ CERROR("Sequence controller is not "
+ "initialized\n");
+ RETURN(-EINVAL);
+ }
+ rc = seq_server_alloc_super(ss_site->ss_control_seq, out, env);
+ break;
+ default:
+ rc = -EINVAL;
+ break;
+ }
- RETURN(rc);
+ RETURN(rc);
}
static int seq_req_handle(struct ptlrpc_request *req,
int seq_server_init(struct lu_server_seq *seq,
- struct dt_device *dev,
- const char *prefix,
- enum lu_mgr_type type,
- struct md_site *ms,
- const struct lu_env *env)
+ struct dt_device *dev,
+ const char *prefix,
+ enum lu_mgr_type type,
+ struct seq_server_site *ss,
+ const struct lu_env *env)
{
int rc, is_srv = (type == LUSTRE_SEQ_SERVER);
ENTRY;
LASSERT(dev != NULL);
LASSERT(prefix != NULL);
- LASSERT(ms != NULL);
- LASSERT(ms->ms_lu != NULL);
+ LASSERT(ss != NULL);
+ LASSERT(ss->ss_lu != NULL);
- seq->lss_cli = NULL;
- seq->lss_type = type;
- seq->lss_site = ms;
- range_init(&seq->lss_space);
+ seq->lss_cli = NULL;
+ seq->lss_type = type;
+ seq->lss_site = ss;
+ range_init(&seq->lss_space);
range_init(&seq->lss_lowater_set);
range_init(&seq->lss_hiwater_set);
LUSTRE_SEQ_ZERO_RANGE:
LUSTRE_SEQ_SPACE_RANGE;
- seq->lss_space.lsr_index = ms->ms_node_id;
+ seq->lss_space.lsr_index = ss->ss_node_id;
LCONSOLE_INFO("%s: No data found "
"on store. Initialize space\n",
seq->lss_name);
if (out != NULL) {
rc = fld_declare_server_create(env,
- seq->lss_site->ms_server_fld,
+ seq->lss_site->ss_server_fld,
out, th);
if (rc)
GOTO(exit, rc);
seq->lss_name, rc);
GOTO(exit, rc);
} else if (out != NULL) {
- rc = fld_server_create(env, seq->lss_site->ms_server_fld, out,
+ rc = fld_server_create(env, seq->lss_site->ss_server_fld, out,
th);
if (rc) {
CERROR("%s: Can't Update fld database, rc %d\n",
!exp->exp_libclient)
out->lsr_flags = LU_SEQ_RANGE_MDT;
- rc = fld_server_handle(lu_site2md(site)->ms_server_fld,
- req->rq_svc_thread->t_env,
- *opc, out, info);
+ rc = fld_server_handle(lu_site2seq(site)->ss_server_fld,
+ req->rq_svc_thread->t_env,
+ *opc, out, info);
} else
rc = err_serious(-EPROTO);
int fid_is_local(const struct lu_env *env,
struct lu_site *site, const struct lu_fid *fid)
{
- int result;
- struct md_site *msite;
- struct lu_seq_range *range;
- struct fld_thread_info *info;
- ENTRY;
+ int result;
+ struct seq_server_site *ss_site;
+ struct lu_seq_range *range;
+ struct fld_thread_info *info;
+ ENTRY;
- info = lu_context_key_get(&env->le_ctx, &fld_thread_key);
- range = &info->fti_lrange;
+ info = lu_context_key_get(&env->le_ctx, &fld_thread_key);
+ range = &info->fti_lrange;
- result = 1; /* conservatively assume fid is local */
- msite = lu_site2md(site);
- if (msite->ms_client_fld != NULL) {
- int rc;
+ result = 1; /* conservatively assume fid is local */
+ ss_site = lu_site2seq(site);
+ if (ss_site->ss_client_fld != NULL) {
+ int rc;
- rc = fld_cache_lookup(msite->ms_client_fld->lcf_cache,
- fid_seq(fid), range);
- if (rc == 0)
- result = (range->lsr_index == msite->ms_node_id);
- }
- return result;
+ rc = fld_cache_lookup(ss_site->ss_client_fld->lcf_cache,
+ fid_seq(fid), range);
+ if (rc == 0)
+ result = (range->lsr_index == ss_site->ss_node_id);
+ }
+ return result;
}
EXPORT_SYMBOL(fid_is_local);
/**
* XXX: a hack! fld has to find md_site via site, remove when possible
*/
- struct md_site *ld_md_site;
+ struct seq_server_site *ld_seq_site;
};
static inline struct lu_site_bkt_data *
/* sync is needed for update operation */
__u32 lss_need_sync;
- /**
- * Pointer to site object, required to access site fld.
- */
- struct md_site *lss_site;
+
+ /**
+ * Pointer to site object, required to access site fld.
+ */
+ struct seq_server_site *lss_site;
};
int seq_query(struct com_thread_info *info);
/* Server methods */
int seq_server_init(struct lu_server_seq *seq,
- struct dt_device *dev,
- const char *prefix,
- enum lu_mgr_type type,
- struct md_site *ls,
- const struct lu_env *env);
+ struct dt_device *dev,
+ const char *prefix,
+ enum lu_mgr_type type,
+ struct seq_server_site *ss,
+ const struct lu_env *env);
void seq_server_fini(struct lu_server_seq *seq,
const struct lu_env *env);
};
/**
- * md-server site.
+ * seq-server site.
*/
-struct md_site {
- struct lu_site *ms_lu;
- /**
- * mds number of this site.
- */
- mdsno_t ms_node_id;
- /**
- * Fid location database
- */
- struct lu_server_fld *ms_server_fld;
- struct lu_client_fld *ms_client_fld;
-
- /**
- * Server Seq Manager
- */
- struct lu_server_seq *ms_server_seq;
-
- /**
- * Controller Seq Manager
- */
- struct lu_server_seq *ms_control_seq;
- struct obd_export *ms_control_exp;
-
- /**
- * Client Seq Manager
- */
- struct lu_client_seq *ms_client_seq;
+struct seq_server_site {
+ struct lu_site *ss_lu;
+ /**
+ * mds number of this site.
+ */
+ mdsno_t ss_node_id;
+ /**
+ * Fid location database
+ */
+ struct lu_server_fld *ss_server_fld;
+ struct lu_client_fld *ss_client_fld;
+
+ /**
+ * Server Seq Manager
+ */
+ struct lu_server_seq *ss_server_seq;
+
+ /**
+ * Controller Seq Manager
+ */
+ struct lu_server_seq *ss_control_seq;
+ struct obd_export *ss_control_exp;
+
+ /**
+ * Client Seq Manager
+ */
+ struct lu_client_seq *ss_client_seq;
};
static inline int lu_device_is_md(const struct lu_device *d)
return container_of0(o->mo_lu.lo_dev, struct md_device, md_lu_dev);
}
-static inline struct md_site *lu_site2md(const struct lu_site *s)
+static inline struct seq_server_site *lu_site2seq(const struct lu_site *s)
{
- return s->ld_md_site;
+ return s->ld_seq_site;
}
static inline int md_device_init(struct md_device *md, struct lu_device_type *t)
int rc;
ENTRY;
- mdsnum = mdt_md_site(mdt)->ms_node_id;
+ mdsnum = mdt_seq_site(mdt)->ss_node_id;
mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
LASSERT(mti != NULL);
info = lu_context_key_get(&env.le_ctx, &mdt_thread_key);
LASSERT(info != NULL);
- tmp = &info->mti_capa_key;
- mdsnum = mdt_md_site(mdt)->ms_node_id;
+ tmp = &info->mti_capa_key;
+ mdsnum = mdt_seq_site(mdt)->ss_node_id;
while (1) {
l_wait_event(thread->t_ctl_waitq,
thread_is_stopping(thread) ||
static int mdt_seq_fini(const struct lu_env *env,
struct mdt_device *m)
{
- struct md_site *ms = mdt_md_site(m);
- ENTRY;
+ struct seq_server_site *ss = mdt_seq_site(m);
+ ENTRY;
- if (ms != NULL) {
- if (ms->ms_server_seq) {
- seq_server_fini(ms->ms_server_seq, env);
- OBD_FREE_PTR(ms->ms_server_seq);
- ms->ms_server_seq = NULL;
- }
+ if (ss == NULL)
+ RETURN(0);
- if (ms->ms_control_seq) {
- seq_server_fini(ms->ms_control_seq, env);
- OBD_FREE_PTR(ms->ms_control_seq);
- ms->ms_control_seq = NULL;
- }
+ if (ss->ss_server_seq) {
+ seq_server_fini(ss->ss_server_seq, env);
+ OBD_FREE_PTR(ss->ss_server_seq);
+ ss->ss_server_seq = NULL;
+ }
- if (ms->ms_client_seq) {
- seq_client_fini(ms->ms_client_seq);
- OBD_FREE_PTR(ms->ms_client_seq);
- ms->ms_client_seq = NULL;
- }
- }
+ if (ss->ss_control_seq) {
+ seq_server_fini(ss->ss_control_seq, env);
+ OBD_FREE_PTR(ss->ss_control_seq);
+ ss->ss_control_seq = NULL;
+ }
- RETURN(0);
+ if (ss->ss_client_seq) {
+ seq_client_fini(ss->ss_client_seq);
+ OBD_FREE_PTR(ss->ss_client_seq);
+ ss->ss_client_seq = NULL;
+ }
+
+ RETURN(0);
}
static int mdt_seq_init(const struct lu_env *env,
const char *uuid,
struct mdt_device *m)
{
- struct md_site *ms;
- char *prefix;
- int rc;
- ENTRY;
+ struct seq_server_site *ss;
+ char *prefix;
+ int rc;
+ ENTRY;
- ms = mdt_md_site(m);
+ ss = mdt_seq_site(m);
- /*
- * This is sequence-controller node. Init seq-controller server on local
- * MDT.
- */
- if (ms->ms_node_id == 0) {
- LASSERT(ms->ms_control_seq == NULL);
+ /*
+ * This is sequence-controller node. Init seq-controller server on local
+ * MDT.
+ */
+ if (ss->ss_node_id == 0) {
+ LASSERT(ss->ss_control_seq == NULL);
- OBD_ALLOC_PTR(ms->ms_control_seq);
- if (ms->ms_control_seq == NULL)
- RETURN(-ENOMEM);
+ OBD_ALLOC_PTR(ss->ss_control_seq);
+ if (ss->ss_control_seq == NULL)
+ RETURN(-ENOMEM);
- rc = seq_server_init(ms->ms_control_seq,
- m->mdt_bottom, uuid,
- LUSTRE_SEQ_CONTROLLER,
- ms,
- env);
+ rc = seq_server_init(ss->ss_control_seq,
+ m->mdt_bottom, uuid,
+ LUSTRE_SEQ_CONTROLLER,
+ ss,
+ env);
- if (rc)
- GOTO(out_seq_fini, rc);
+ if (rc)
+ GOTO(out_seq_fini, rc);
- OBD_ALLOC_PTR(ms->ms_client_seq);
- if (ms->ms_client_seq == NULL)
- GOTO(out_seq_fini, rc = -ENOMEM);
+ OBD_ALLOC_PTR(ss->ss_client_seq);
+ if (ss->ss_client_seq == NULL)
+ GOTO(out_seq_fini, rc = -ENOMEM);
- OBD_ALLOC(prefix, MAX_OBD_NAME + 5);
- if (prefix == NULL) {
- OBD_FREE_PTR(ms->ms_client_seq);
- GOTO(out_seq_fini, rc = -ENOMEM);
- }
+ OBD_ALLOC(prefix, MAX_OBD_NAME + 5);
+ if (prefix == NULL) {
+ OBD_FREE_PTR(ss->ss_client_seq);
+ GOTO(out_seq_fini, rc = -ENOMEM);
+ }
- snprintf(prefix, MAX_OBD_NAME + 5, "ctl-%s",
- uuid);
+ snprintf(prefix, MAX_OBD_NAME + 5, "ctl-%s",
+ uuid);
- /*
- * Init seq-controller client after seq-controller server is
- * ready. Pass ms->ms_control_seq to it for direct talking.
- */
- rc = seq_client_init(ms->ms_client_seq, NULL,
- LUSTRE_SEQ_METADATA, prefix,
- ms->ms_control_seq);
- OBD_FREE(prefix, MAX_OBD_NAME + 5);
+ /*
+ * Init seq-controller client after seq-controller server is
+ * ready. Pass ss->ss_control_seq to it for direct talking.
+ */
+ rc = seq_client_init(ss->ss_client_seq, NULL,
+ LUSTRE_SEQ_METADATA, prefix,
+ ss->ss_control_seq);
+ OBD_FREE(prefix, MAX_OBD_NAME + 5);
- if (rc)
- GOTO(out_seq_fini, rc);
- }
+ if (rc)
+ GOTO(out_seq_fini, rc);
+ }
- /* Init seq-server on local MDT */
- LASSERT(ms->ms_server_seq == NULL);
+ /* Init seq-server on local MDT */
+ LASSERT(ss->ss_server_seq == NULL);
- OBD_ALLOC_PTR(ms->ms_server_seq);
- if (ms->ms_server_seq == NULL)
- GOTO(out_seq_fini, rc = -ENOMEM);
+ OBD_ALLOC_PTR(ss->ss_server_seq);
+ if (ss->ss_server_seq == NULL)
+ GOTO(out_seq_fini, rc = -ENOMEM);
- rc = seq_server_init(ms->ms_server_seq,
- m->mdt_bottom, uuid,
- LUSTRE_SEQ_SERVER,
- ms,
- env);
- if (rc)
- GOTO(out_seq_fini, rc = -ENOMEM);
+ rc = seq_server_init(ss->ss_server_seq,
+ m->mdt_bottom, uuid,
+ LUSTRE_SEQ_SERVER,
+ ss,
+ env);
+ if (rc)
+ GOTO(out_seq_fini, rc = -ENOMEM);
- /* Assign seq-controller client to local seq-server. */
- if (ms->ms_node_id == 0) {
- LASSERT(ms->ms_client_seq != NULL);
+ /* Assign seq-controller client to local seq-server. */
+ if (ss->ss_node_id == 0) {
+ LASSERT(ss->ss_client_seq != NULL);
- rc = seq_server_set_cli(ms->ms_server_seq,
- ms->ms_client_seq,
- env);
- }
+ rc = seq_server_set_cli(ss->ss_server_seq,
+ ss->ss_client_seq,
+ env);
+ }
- EXIT;
+ EXIT;
out_seq_fini:
- if (rc)
- mdt_seq_fini(env, m);
+ if (rc)
+ mdt_seq_fini(env, m);
- return rc;
+ return rc;
}
/*
* Init client sequence manager which is used by local MDS to talk to sequence
struct mdt_device *m,
struct lustre_cfg *cfg)
{
- struct md_site *ms = mdt_md_site(m);
+ struct seq_server_site *ss = mdt_seq_site(m);
struct obd_device *mdc;
struct obd_uuid *uuidp, *mdcuuidp;
char *uuid_str, *mdc_uuid_str;
RETURN(-EINVAL);
}
- /* check if this is adding the first MDC and controller is not yet
- * initialized. */
- if (index != 0 || ms->ms_client_seq)
- RETURN(0);
+ /* check if this is adding the first MDC and controller is not yet
+ * initialized. */
+ if (index != 0 || ss->ss_client_seq)
+ RETURN(0);
uuid_str = lustre_cfg_string(cfg, 1);
mdc_uuid_str = lustre_cfg_string(cfg, 4);
CERROR("target %s not set up\n", mdc->obd_name);
rc = -EINVAL;
} else {
- LASSERT(ms->ms_control_exp);
- OBD_ALLOC_PTR(ms->ms_client_seq);
- if (ms->ms_client_seq != NULL) {
- char *prefix;
-
- OBD_ALLOC(prefix, MAX_OBD_NAME + 5);
- if (!prefix)
- RETURN(-ENOMEM);
-
- snprintf(prefix, MAX_OBD_NAME + 5, "ctl-%s",
- mdc->obd_name);
-
- rc = seq_client_init(ms->ms_client_seq,
- ms->ms_control_exp,
- LUSTRE_SEQ_METADATA,
- prefix, NULL);
- OBD_FREE(prefix, MAX_OBD_NAME + 5);
- } else
- rc = -ENOMEM;
+ LASSERT(ss->ss_control_exp);
+ OBD_ALLOC_PTR(ss->ss_client_seq);
+ if (ss->ss_client_seq != NULL) {
+ char *prefix;
+
+ OBD_ALLOC(prefix, MAX_OBD_NAME + 5);
+ if (!prefix)
+ RETURN(-ENOMEM);
+
+ snprintf(prefix, MAX_OBD_NAME + 5, "ctl-%s",
+ mdc->obd_name);
+
+ rc = seq_client_init(ss->ss_client_seq,
+ ss->ss_control_exp,
+ LUSTRE_SEQ_METADATA,
+ prefix, NULL);
+ OBD_FREE(prefix, MAX_OBD_NAME + 5);
+ } else
+ rc = -ENOMEM;
- if (rc)
- RETURN(rc);
+ if (rc)
+ RETURN(rc);
- LASSERT(ms->ms_server_seq != NULL);
- rc = seq_server_set_cli(ms->ms_server_seq, ms->ms_client_seq,
- env);
+ LASSERT(ss->ss_server_seq != NULL);
+ rc = seq_server_set_cli(ss->ss_server_seq, ss->ss_client_seq,
+ env);
}
RETURN(rc);
static void mdt_seq_fini_cli(struct mdt_device *m)
{
- struct md_site *ms;
+ struct seq_server_site *ss;
- ENTRY;
+ ENTRY;
- ms = mdt_md_site(m);
+ ss = mdt_seq_site(m);
- if (ms != NULL) {
- if (ms->ms_server_seq)
- seq_server_set_cli(ms->ms_server_seq,
- NULL, NULL);
+ if (ss == NULL)
+ RETURN_EXIT;
- if (ms->ms_control_exp) {
- class_export_put(ms->ms_control_exp);
- ms->ms_control_exp = NULL;
- }
- }
- EXIT;
+ if (ss->ss_server_seq)
+ seq_server_set_cli(ss->ss_server_seq, NULL, NULL);
+
+ if (ss->ss_control_exp) {
+ class_export_put(ss->ss_control_exp);
+ ss->ss_control_exp = NULL;
+ }
+
+ EXIT;
}
/*
static int mdt_fld_fini(const struct lu_env *env,
struct mdt_device *m)
{
- struct md_site *ms = mdt_md_site(m);
- ENTRY;
+ struct seq_server_site *ss = mdt_seq_site(m);
+ ENTRY;
- if (ms && ms->ms_server_fld) {
- fld_server_fini(env, ms->ms_server_fld);
- OBD_FREE_PTR(ms->ms_server_fld);
- ms->ms_server_fld = NULL;
- }
+ if (ss && ss->ss_server_fld) {
+ fld_server_fini(env, ss->ss_server_fld);
+ OBD_FREE_PTR(ss->ss_server_fld);
+ ss->ss_server_fld = NULL;
+ }
- RETURN(0);
+ RETURN(0);
}
static int mdt_fld_init(const struct lu_env *env,
const char *uuid,
struct mdt_device *m)
{
- struct md_site *ms;
- int rc;
- ENTRY;
+ struct seq_server_site *ss;
+ int rc;
+ ENTRY;
- ms = mdt_md_site(m);
+ ss = mdt_seq_site(m);
- OBD_ALLOC_PTR(ms->ms_server_fld);
- if (ms->ms_server_fld == NULL)
- RETURN(rc = -ENOMEM);
+ OBD_ALLOC_PTR(ss->ss_server_fld);
+ if (ss->ss_server_fld == NULL)
+ RETURN(rc = -ENOMEM);
- rc = fld_server_init(env, ms->ms_server_fld, m->mdt_bottom, uuid,
- ms->ms_node_id);
- if (rc) {
- OBD_FREE_PTR(ms->ms_server_fld);
- ms->ms_server_fld = NULL;
- RETURN(rc);
- }
+ rc = fld_server_init(env, ss->ss_server_fld, m->mdt_bottom, uuid,
+ ss->ss_node_id);
+ if (rc) {
+ OBD_FREE_PTR(ss->ss_server_fld);
+ ss->ss_server_fld = NULL;
+ RETURN(rc);
+ }
- RETURN(0);
+ RETURN(0);
}
static void mdt_stack_fini(const struct lu_env *env,
LASSERT(mdt->mdt_qmt_dev == NULL);
/* quota master is on MDT0 only for now */
- if (mdt->mdt_mite.ms_node_id != 0)
+ if (mdt->mdt_seq_site.ss_node_id != 0)
RETURN(0);
/* MGS generates config commands which look as follows:
struct lustre_mount_info *lmi = NULL;
struct lustre_sb_info *lsi;
struct lu_site *s;
- struct md_site *mite;
+ struct seq_server_site *ss_site;
const char *identity_upcall = "NONE";
struct md_device *next;
int rc;
}
s = m->mdt_md_dev.md_lu_dev.ld_site;
- mite = &m->mdt_mite;
- s->ld_md_site = mite;
- mite->ms_lu = s;
+ ss_site = &m->mdt_seq_site;
+ s->ld_seq_site = ss_site;
+ ss_site->ss_lu = s;
/* set server index */
- mite->ms_node_id = node_id;
+ ss_site->ss_node_id = node_id;
- /* failover is the default
- * FIXME: we do not failout mds0/mgs, which may cause some problems.
- * assumed whose ms_node_id == 0 XXX
- * */
+ /* failover is the default
+ * FIXME: we do not failout mds0/mgs, which may cause some problems.
+ * assumed whose ss_node_id == 0 XXX
+ * */
obd->obd_replayable = 1;
/* No connection accepted until configurations will finish */
obd->obd_no_conn = 1;
struct mdt_device {
/* super-class */
struct md_device mdt_md_dev;
- struct md_site mdt_mite;
+ struct seq_server_site mdt_seq_site;
struct ptlrpc_service *mdt_regular_service;
struct ptlrpc_service *mdt_readpage_service;
struct ptlrpc_service *mdt_xmds_service;
return mdt->mdt_md_dev.md_lu_dev.ld_site;
}
-static inline struct md_site *mdt_md_site(struct mdt_device *mdt)
+static inline struct seq_server_site *mdt_seq_site(struct mdt_device *mdt)
{
- return &mdt->mdt_mite;
+ return &mdt->mdt_seq_site;
}
static inline void mdt_export_evict(struct obd_export *exp)
ldlm_policy_data_t *policy = &info->mti_policy;
struct ldlm_res_id *res_id = &info->mti_res_id;
__u64 flags = 0;
- struct md_site *ms;
+ struct seq_server_site *ss;
int rc;
ENTRY;
- ms = mdt_md_site(info->mti_mdt);
- fid_build_reg_res_name(&LUSTRE_BFL_FID, res_id);
+ ss = mdt_seq_site(info->mti_mdt);
+ fid_build_reg_res_name(&LUSTRE_BFL_FID, res_id);
memset(policy, 0, sizeof *policy);
policy->l_inodebits.bits = MDS_INODELOCK_UPDATE;
- if (ms->ms_control_exp == NULL) {
+ if (ss->ss_control_exp == NULL) {
flags = LDLM_FL_LOCAL_ONLY | LDLM_FL_ATOMIC_CB;
/*
} else {
struct ldlm_enqueue_info einfo = { LDLM_IBITS, LCK_EX,
ldlm_blocking_ast, ldlm_completion_ast, NULL, NULL, NULL };
- /*
- * This is the case mdt0 is remote node, issue DLM lock like
- * other clients.
- */
- rc = ldlm_cli_enqueue(ms->ms_control_exp, NULL, &einfo, res_id,
+
+ /*
+ * This is the case mdt0 is remote node, issue DLM lock like
+ * other clients.
+ */
+ rc = ldlm_cli_enqueue(ss->ss_control_exp, NULL, &einfo, res_id,
policy, &flags, NULL, 0, LVB_T_NONE, lh,
0);
}
#define ECHO_SEQ_WIDTH 0xffffffff
static int echo_fid_init(struct echo_device *ed, char *obd_name,
- struct md_site *ms)
+ struct seq_server_site *ss)
{
char *prefix;
int rc;
snprintf(prefix, MAX_OBD_NAME + 5, "srv-%s", obd_name);
- /* Init client side sequence-manager */
- rc = seq_client_init(ed->ed_cl_seq, NULL,
- LUSTRE_SEQ_METADATA,
- prefix, ms->ms_server_seq);
+ /* Init client side sequence-manager */
+ rc = seq_client_init(ed->ed_cl_seq, NULL,
+ LUSTRE_SEQ_METADATA,
+ prefix, ss->ss_server_seq);
ed->ed_cl_seq->lcs_width = ECHO_SEQ_WIDTH;
OBD_FREE(prefix, MAX_OBD_NAME + 5);
if (rc)
ed->ed_site_myself.cs_lu = *ls;
ed->ed_site = &ed->ed_site_myself;
ed->ed_cl.cd_lu_dev.ld_site = &ed->ed_site_myself.cs_lu;
- rc = echo_fid_init(ed, obd->obd_name, lu_site2md(ls));
- if (rc) {
- CERROR("echo fid init error %d\n", rc);
- GOTO(out, rc);
- }
+ rc = echo_fid_init(ed, obd->obd_name, lu_site2seq(ls));
+ if (rc) {
+ CERROR("echo fid init error %d\n", rc);
+ GOTO(out, rc);
+ }
} else {
/* if echo client is to be stacked upon ost device, the next is
* NULL since ost is not a clio device so far */
return LDISKFS_SB(osd_sb(dev))->s_journal;
}
-static inline struct md_site *osd_md_site(struct osd_device *osd)
+static inline struct seq_server_site *osd_seq_site(struct osd_device *osd)
{
- return osd->od_dt_dev.dd_lu_dev.ld_site->ld_md_site;
+ return osd->od_dt_dev.dd_lu_dev.ld_site->ld_seq_site;
}
static inline char *osd_name(struct osd_device *osd)
git://git.whamcloud.com / fs / lustre-release.git / commitdiff