static int mdt_regular_handle(struct ptlrpc_request *req);
static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info, __u32 flags);
-static struct lu_object_operations mdt_obj_ops;
+static const struct lu_object_operations mdt_obj_ops;
int mdt_get_disposition(struct ldlm_reply *rep, int flag)
{
return rc;
}
-static struct lu_device_operations mdt_lu_ops;
+static const struct lu_device_operations mdt_lu_ops;
static int lu_device_is_mdt(struct lu_device *d)
{
ENTRY;
CDEBUG(D_INFO, "Find object for "DFID"\n", PFID(f));
- o = lu_object_find(env, d->mdt_md_dev.md_lu_dev.ld_site, f);
+ o = lu_object_find(env, &d->mdt_md_dev.md_lu_dev, f, NULL);
if (unlikely(IS_ERR(o)))
m = (struct mdt_object *)o;
else
}
/*
- * Finish res_id initializing by name hash marking patr of
+ * Finish res_id initializing by name hash marking part of
* directory which is taking modification.
*/
res_id->name[LUSTRE_RES_ID_HSH_OFF] = lh->mlh_pdo_hash;
* lock.
*/
if (new_lock == NULL)
- new_lock = ldlm_handle2lock(&lh->mlh_reg_lh);
+ new_lock = ldlm_handle2lock_long(&lh->mlh_reg_lh, 0);
if (new_lock == NULL && (flags & LDLM_FL_INTENT_ONLY)) {
lh->mlh_reg_lh.cookie = 0;
* Fixup the lock to be given to the client.
*/
lock_res_and_lock(new_lock);
- new_lock->l_readers = 0;
- new_lock->l_writers = 0;
+ /* Zero new_lock->l_readers and new_lock->l_writers without triggering
+ * possible blocking AST. */
+ while (new_lock->l_readers > 0) {
+ lu_ref_del(&new_lock->l_reference, "reader", new_lock);
+ lu_ref_del(&new_lock->l_reference, "user", new_lock);
+ new_lock->l_readers--;
+ }
+ while (new_lock->l_writers > 0) {
+ lu_ref_del(&new_lock->l_reference, "writer", new_lock);
+ lu_ref_del(&new_lock->l_reference, "user", new_lock);
+ new_lock->l_writers--;
+ }
new_lock->l_export = class_export_get(req->rq_export);
new_lock->l_blocking_ast = lock->l_blocking_ast;
&new_lock->l_exp_hash);
unlock_res_and_lock(new_lock);
- LDLM_LOCK_PUT(new_lock);
+ LDLM_LOCK_RELEASE(new_lock);
lh->mlh_reg_lh.cookie = 0;
RETURN(ELDLM_LOCK_REPLACED);
static void mdt_seq_adjust(const struct lu_env *env,
struct mdt_device *m, int lost)
{
- struct lu_site *ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ struct md_site *ms = mdt_md_site(m);
struct lu_range out;
ENTRY;
- LASSERT(ls && ls->ls_server_seq);
+ LASSERT(ms && ms->ms_server_seq);
LASSERT(lost >= 0);
/* get extra seq from seq_server, moving it's range up */
while (lost-- > 0) {
- seq_server_alloc_meta(ls->ls_server_seq, NULL, &out, env);
+ seq_server_alloc_meta(ms->ms_server_seq, NULL, &out, env);
}
EXIT;
}
static int mdt_seq_fini(const struct lu_env *env,
struct mdt_device *m)
{
- struct lu_site *ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ struct md_site *ms = mdt_md_site(m);
ENTRY;
- if (ls && ls->ls_server_seq) {
- seq_server_fini(ls->ls_server_seq, env);
- OBD_FREE_PTR(ls->ls_server_seq);
- ls->ls_server_seq = NULL;
+ 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 (ls && ls->ls_control_seq) {
- seq_server_fini(ls->ls_control_seq, env);
- OBD_FREE_PTR(ls->ls_control_seq);
- ls->ls_control_seq = NULL;
+ 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 (ls && ls->ls_client_seq) {
- seq_client_fini(ls->ls_client_seq);
- OBD_FREE_PTR(ls->ls_client_seq);
- ls->ls_client_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;
+ }
}
RETURN(0);
const char *uuid,
struct mdt_device *m)
{
- struct lu_site *ls;
+ struct md_site *ms;
char *prefix;
int rc;
ENTRY;
- ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ ms = mdt_md_site(m);
/*
* This is sequence-controller node. Init seq-controller server on local
* MDT.
*/
- if (ls->ls_node_id == 0) {
- LASSERT(ls->ls_control_seq == NULL);
+ if (ms->ms_node_id == 0) {
+ LASSERT(ms->ms_control_seq == NULL);
- OBD_ALLOC_PTR(ls->ls_control_seq);
- if (ls->ls_control_seq == NULL)
+ OBD_ALLOC_PTR(ms->ms_control_seq);
+ if (ms->ms_control_seq == NULL)
RETURN(-ENOMEM);
- rc = seq_server_init(ls->ls_control_seq,
+ rc = seq_server_init(ms->ms_control_seq,
m->mdt_bottom, uuid,
LUSTRE_SEQ_CONTROLLER,
env);
if (rc)
GOTO(out_seq_fini, rc);
- OBD_ALLOC_PTR(ls->ls_client_seq);
- if (ls->ls_client_seq == NULL)
+ OBD_ALLOC_PTR(ms->ms_client_seq);
+ if (ms->ms_client_seq == NULL)
GOTO(out_seq_fini, rc = -ENOMEM);
OBD_ALLOC(prefix, MAX_OBD_NAME + 5);
if (prefix == NULL) {
- OBD_FREE_PTR(ls->ls_client_seq);
+ OBD_FREE_PTR(ms->ms_client_seq);
GOTO(out_seq_fini, rc = -ENOMEM);
}
/*
* Init seq-controller client after seq-controller server is
- * ready. Pass ls->ls_control_seq to it for direct talking.
+ * ready. Pass ms->ms_control_seq to it for direct talking.
*/
- rc = seq_client_init(ls->ls_client_seq, NULL,
+ rc = seq_client_init(ms->ms_client_seq, NULL,
LUSTRE_SEQ_METADATA, prefix,
- ls->ls_control_seq);
+ ms->ms_control_seq);
OBD_FREE(prefix, MAX_OBD_NAME + 5);
if (rc)
}
/* Init seq-server on local MDT */
- LASSERT(ls->ls_server_seq == NULL);
+ LASSERT(ms->ms_server_seq == NULL);
- OBD_ALLOC_PTR(ls->ls_server_seq);
- if (ls->ls_server_seq == NULL)
+ OBD_ALLOC_PTR(ms->ms_server_seq);
+ if (ms->ms_server_seq == NULL)
GOTO(out_seq_fini, rc = -ENOMEM);
- rc = seq_server_init(ls->ls_server_seq,
+ rc = seq_server_init(ms->ms_server_seq,
m->mdt_bottom, uuid,
LUSTRE_SEQ_SERVER,
env);
GOTO(out_seq_fini, rc = -ENOMEM);
/* Assign seq-controller client to local seq-server. */
- if (ls->ls_node_id == 0) {
- LASSERT(ls->ls_client_seq != NULL);
+ if (ms->ms_node_id == 0) {
+ LASSERT(ms->ms_client_seq != NULL);
- rc = seq_server_set_cli(ls->ls_server_seq,
- ls->ls_client_seq,
+ rc = seq_server_set_cli(ms->ms_server_seq,
+ ms->ms_client_seq,
env);
}
struct mdt_device *m,
struct lustre_cfg *cfg)
{
- struct lu_site *ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ struct md_site *ms = mdt_md_site(m);
struct obd_device *mdc;
struct obd_uuid *uuidp, *mdcuuidp;
char *uuid_str, *mdc_uuid_str;
/* check if this is adding the first MDC and controller is not yet
* initialized. */
- if (index != 0 || ls->ls_client_seq)
+ if (index != 0 || ms->ms_client_seq)
RETURN(0);
uuid_str = lustre_cfg_string(cfg, 1);
CERROR("target %s not set up\n", mdc->obd_name);
rc = -EINVAL;
} else {
- LASSERT(ls->ls_control_exp);
- OBD_ALLOC_PTR(ls->ls_client_seq);
- if (ls->ls_client_seq != NULL) {
+ 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);
snprintf(prefix, MAX_OBD_NAME + 5, "ctl-%s",
mdc->obd_name);
- rc = seq_client_init(ls->ls_client_seq,
- ls->ls_control_exp,
+ rc = seq_client_init(ms->ms_client_seq,
+ ms->ms_control_exp,
LUSTRE_SEQ_METADATA,
prefix, NULL);
OBD_FREE(prefix, MAX_OBD_NAME + 5);
if (rc)
RETURN(rc);
- LASSERT(ls->ls_server_seq != NULL);
- rc = seq_server_set_cli(ls->ls_server_seq, ls->ls_client_seq,
+ LASSERT(ms->ms_server_seq != NULL);
+ rc = seq_server_set_cli(ms->ms_server_seq, ms->ms_client_seq,
env);
}
static void mdt_seq_fini_cli(struct mdt_device *m)
{
- struct lu_site *ls;
+ struct md_site *ms;
ENTRY;
- ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ ms = mdt_md_site(m);
- if (ls && ls->ls_server_seq)
- seq_server_set_cli(ls->ls_server_seq,
+ if (ms != NULL) {
+ if (ms->ms_server_seq)
+ seq_server_set_cli(ms->ms_server_seq,
NULL, NULL);
- if (ls && ls->ls_control_exp) {
- class_export_put(ls->ls_control_exp);
- ls->ls_control_exp = NULL;
+ if (ms->ms_control_exp) {
+ class_export_put(ms->ms_control_exp);
+ ms->ms_control_exp = NULL;
+ }
}
EXIT;
}
static int mdt_fld_fini(const struct lu_env *env,
struct mdt_device *m)
{
- struct lu_site *ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ struct md_site *ms = mdt_md_site(m);
ENTRY;
- if (ls && ls->ls_server_fld) {
- fld_server_fini(ls->ls_server_fld, env);
- OBD_FREE_PTR(ls->ls_server_fld);
- ls->ls_server_fld = NULL;
+ if (ms && ms->ms_server_fld) {
+ fld_server_fini(ms->ms_server_fld, env);
+ OBD_FREE_PTR(ms->ms_server_fld);
+ ms->ms_server_fld = NULL;
}
RETURN(0);
const char *uuid,
struct mdt_device *m)
{
- struct lu_site *ls;
+ struct md_site *ms;
int rc;
ENTRY;
- ls = m->mdt_md_dev.md_lu_dev.ld_site;
+ ms = mdt_md_site(m);
- OBD_ALLOC_PTR(ls->ls_server_fld);
- if (ls->ls_server_fld == NULL)
+ OBD_ALLOC_PTR(ms->ms_server_fld);
+ if (ms->ms_server_fld == NULL)
RETURN(rc = -ENOMEM);
- rc = fld_server_init(ls->ls_server_fld,
+ rc = fld_server_init(ms->ms_server_fld,
m->mdt_bottom, uuid, env);
if (rc) {
- OBD_FREE_PTR(ls->ls_server_fld);
- ls->ls_server_fld = NULL;
+ OBD_FREE_PTR(ms->ms_server_fld);
+ ms->ms_server_fld = NULL;
RETURN(rc);
}
m->mdt_bottom = NULL;
}
-static struct lu_device *mdt_layer_setup(const struct lu_env *env,
+static struct lu_device *mdt_layer_setup(struct lu_env *env,
const char *typename,
struct lu_device *child,
struct lustre_cfg *cfg)
GOTO(out_alloc, rc);
}
lu_device_get(d);
+ lu_ref_add(&d->ld_reference, "lu-stack", &lu_site_init);
RETURN(d);
return ERR_PTR(rc);
}
-static int mdt_stack_init(const struct lu_env *env,
+static int mdt_stack_init(struct lu_env *env,
struct mdt_device *m, struct lustre_cfg *cfg)
{
struct lu_device *d = &m->mdt_md_dev.md_lu_dev;
mdt_stack_fini(env, m, md2lu_dev(m->mdt_child));
if (ls) {
+ struct md_site *mite;
+
lu_site_fini(ls);
- OBD_FREE_PTR(ls);
+ mite = lu_site2md(ls);
+ OBD_FREE_PTR(mite);
d->ld_site = NULL;
}
LASSERT(atomic_read(&d->ld_ref) == 0);
struct lustre_mount_info *lmi;
struct lustre_sb_info *lsi;
struct lu_site *s;
+ struct md_site *mite;
const char *identity_upcall = "NONE";
int rc;
ENTRY;
spin_lock_init(&m->mdt_client_bitmap_lock);
- OBD_ALLOC_PTR(s);
- if (s == NULL)
+ OBD_ALLOC_PTR(mite);
+ if (mite == NULL)
RETURN(-ENOMEM);
md_device_init(&m->mdt_md_dev, ldt);
+ s = &mite->ms_lu;
+
m->mdt_md_dev.md_lu_dev.ld_ops = &mdt_lu_ops;
m->mdt_md_dev.md_lu_dev.ld_obd = obd;
/* set this lu_device to obd, because error handling need it */
/* set server index */
LASSERT(num);
- s->ls_node_id = simple_strtol(num, NULL, 10);
+ lu_site2md(s)->ms_node_id = simple_strtol(num, NULL, 10);
/* failover is the default
* FIXME: we do not failout mds0/mgs, which may cause some problems.
}
/* init the stack */
- rc = mdt_stack_init(env, m, cfg);
+ rc = mdt_stack_init((struct lu_env *)env, m, cfg);
if (rc) {
CERROR("Can't init device stack, rc %d\n", rc);
GOTO(err_fini_proc, rc);
RETURN(NULL);
}
-static int mdt_object_init(const struct lu_env *env, struct lu_object *o)
+static int mdt_object_init(const struct lu_env *env, struct lu_object *o,
+ const struct lu_object_conf *_)
{
struct mdt_device *d = mdt_dev(o->lo_dev);
struct lu_device *under;
EXIT;
}
-static int mdt_object_print(const struct lu_env *env, void *cookie,
- lu_printer_t p, const struct lu_object *o)
-{
- return (*p)(env, cookie, LUSTRE_MDT_NAME"-object@%p", o);
-}
-
-static struct lu_device_operations mdt_lu_ops = {
+static const struct lu_device_operations mdt_lu_ops = {
.ldo_object_alloc = mdt_object_alloc,
.ldo_process_config = mdt_process_config
};
-static struct lu_object_operations mdt_obj_ops = {
+static const struct lu_object_operations mdt_obj_ops = {
.loo_object_init = mdt_object_init,
- .loo_object_free = mdt_object_free,
- .loo_object_print = mdt_object_print
+ .loo_object_free = mdt_object_free
};
/* mds_connect_internal */
.ldto_init = mdt_type_init,
.ldto_fini = mdt_type_fini,
+ .ldto_start = mdt_type_start,
+ .ldto_stop = mdt_type_stop,
+
.ldto_device_alloc = mdt_device_alloc,
.ldto_device_free = mdt_device_free,
.ldto_device_fini = mdt_device_fini
git://git.whamcloud.com / fs / lustre-release.git / blobdiff