* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
*
* Author: Mike Pershin <tappro@clusterfs.com>
*/
-
+/**
+ * \addtogroup cmm
+ * @{
+ */
#ifndef EXPORT_SYMTAB
# define EXPORT_SYMTAB
#endif
#include <lustre_ver.h>
#include "cmm_internal.h"
#include "mdc_internal.h"
+#ifdef HAVE_QUOTA_SUPPORT
+# include <lustre_quota.h>
+#endif
-static struct obd_ops cmm_obd_device_ops = {
+struct obd_ops cmm_obd_device_ops = {
.o_owner = THIS_MODULE
};
static inline int lu_device_is_cmm(struct lu_device *d)
{
- return ergo(d != NULL && d->ld_ops != NULL, d->ld_ops == &cmm_lu_ops);
+ return ergo(d != NULL && d->ld_ops != NULL, d->ld_ops == &cmm_lu_ops);
}
int cmm_root_get(const struct lu_env *env, struct md_device *md,
}
static int cmm_statfs(const struct lu_env *env, struct md_device *md,
- struct kstatfs *sfs)
+ cfs_kstatfs_t *sfs)
{
struct cmm_device *cmm_dev = md2cmm_dev(md);
- int rc;
+ int rc;
ENTRY;
rc = cmm_child_ops(cmm_dev)->mdo_statfs(env,
RETURN(rc);
}
+static int cmm_llog_ctxt_get(const struct lu_env *env, struct md_device *m,
+ int idx, void **h)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ rc = cmm_child_ops(cmm_dev)->mdo_llog_ctxt_get(env, cmm_dev->cmm_child,
+ idx, h);
+ RETURN(rc);
+}
+
+#ifdef HAVE_QUOTA_SUPPORT
+/**
+ * \name Quota functions
+ * @{
+ */
+static int cmm_quota_notify(const struct lu_env *env, struct md_device *m)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_notify(env,
+ cmm_dev->cmm_child);
+ RETURN(rc);
+}
+
+static int cmm_quota_setup(const struct lu_env *env, struct md_device *m,
+ void *data)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_setup(env,
+ cmm_dev->cmm_child,
+ data);
+ RETURN(rc);
+}
+
+static int cmm_quota_cleanup(const struct lu_env *env, struct md_device *m)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_cleanup(env,
+ cmm_dev->cmm_child);
+ RETURN(rc);
+}
+
+static int cmm_quota_recovery(const struct lu_env *env, struct md_device *m)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_recovery(env,
+ cmm_dev->cmm_child);
+ RETURN(rc);
+}
+
+static int cmm_quota_check(const struct lu_env *env, struct md_device *m,
+ __u32 type)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_check(env,
+ cmm_dev->cmm_child,
+ type);
+ RETURN(rc);
+}
+
+static int cmm_quota_on(const struct lu_env *env, struct md_device *m,
+ __u32 type)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_on(env,
+ cmm_dev->cmm_child,
+ type);
+ RETURN(rc);
+}
+
+static int cmm_quota_off(const struct lu_env *env, struct md_device *m,
+ __u32 type)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_off(env,
+ cmm_dev->cmm_child,
+ type);
+ RETURN(rc);
+}
+
+static int cmm_quota_setinfo(const struct lu_env *env, struct md_device *m,
+ __u32 type, __u32 id, struct obd_dqinfo *dqinfo)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_setinfo(env,
+ cmm_dev->cmm_child,
+ type, id, dqinfo);
+ RETURN(rc);
+}
+
+static int cmm_quota_getinfo(const struct lu_env *env,
+ const struct md_device *m,
+ __u32 type, __u32 id, struct obd_dqinfo *dqinfo)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev((struct md_device *)m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_getinfo(env,
+ cmm_dev->cmm_child,
+ type, id, dqinfo);
+ RETURN(rc);
+}
+
+static int cmm_quota_setquota(const struct lu_env *env, struct md_device *m,
+ __u32 type, __u32 id, struct obd_dqblk *dqblk)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_setquota(env,
+ cmm_dev->cmm_child,
+ type, id, dqblk);
+ RETURN(rc);
+}
+
+static int cmm_quota_getquota(const struct lu_env *env,
+ const struct md_device *m,
+ __u32 type, __u32 id, struct obd_dqblk *dqblk)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev((struct md_device *)m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_getquota(env,
+ cmm_dev->cmm_child,
+ type, id, dqblk);
+ RETURN(rc);
+}
+
+static int cmm_quota_getoinfo(const struct lu_env *env,
+ const struct md_device *m,
+ __u32 type, __u32 id, struct obd_dqinfo *dqinfo)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev((struct md_device *)m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_getoinfo(env,
+ cmm_dev->cmm_child,
+ type, id, dqinfo);
+ RETURN(rc);
+}
+
+static int cmm_quota_getoquota(const struct lu_env *env,
+ const struct md_device *m,
+ __u32 type, __u32 id, struct obd_dqblk *dqblk)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev((struct md_device *)m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_getoquota(env,
+ cmm_dev->cmm_child,
+ type, id, dqblk);
+ RETURN(rc);
+}
+
+static int cmm_quota_invalidate(const struct lu_env *env, struct md_device *m,
+ __u32 type)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_invalidate(env,
+ cmm_dev->cmm_child,
+ type);
+ RETURN(rc);
+}
+
+static int cmm_quota_finvalidate(const struct lu_env *env, struct md_device *m,
+ __u32 type)
+{
+ struct cmm_device *cmm_dev = md2cmm_dev(m);
+ int rc;
+ ENTRY;
+
+ /* disable quota for CMD case temporary. */
+ if (cmm_dev->cmm_tgt_count)
+ RETURN(-EOPNOTSUPP);
+
+ rc = cmm_child_ops(cmm_dev)->mdo_quota.mqo_finvalidate(env,
+ cmm_dev->cmm_child,
+ type);
+ RETURN(rc);
+}
+/** @} */
+#endif
+
+int cmm_iocontrol(const struct lu_env *env, struct md_device *m,
+ unsigned int cmd, int len, void *data)
+{
+ struct md_device *next = md2cmm_dev(m)->cmm_child;
+ int rc;
+
+ ENTRY;
+ rc = next->md_ops->mdo_iocontrol(env, next, cmd, len, data);
+ RETURN(rc);
+}
+
+
static const struct md_device_operations cmm_md_ops = {
.mdo_statfs = cmm_statfs,
.mdo_root_get = cmm_root_get,
.mdo_maxsize_get = cmm_maxsize_get,
.mdo_init_capa_ctxt = cmm_init_capa_ctxt,
.mdo_update_capa_key = cmm_update_capa_key,
+ .mdo_llog_ctxt_get = cmm_llog_ctxt_get,
+ .mdo_iocontrol = cmm_iocontrol,
+#ifdef HAVE_QUOTA_SUPPORT
+ .mdo_quota = {
+ .mqo_notify = cmm_quota_notify,
+ .mqo_setup = cmm_quota_setup,
+ .mqo_cleanup = cmm_quota_cleanup,
+ .mqo_recovery = cmm_quota_recovery,
+ .mqo_check = cmm_quota_check,
+ .mqo_on = cmm_quota_on,
+ .mqo_off = cmm_quota_off,
+ .mqo_setinfo = cmm_quota_setinfo,
+ .mqo_getinfo = cmm_quota_getinfo,
+ .mqo_setquota = cmm_quota_setquota,
+ .mqo_getquota = cmm_quota_getquota,
+ .mqo_getoinfo = cmm_quota_getoinfo,
+ .mqo_getoquota = cmm_quota_getoquota,
+ .mqo_invalidate = cmm_quota_invalidate,
+ .mqo_finvalidate = cmm_quota_finvalidate
+ }
+#endif
};
extern struct lu_device_type mdc_device_type;
-
+/**
+ * Init MDC.
+ */
static int cmm_post_init_mdc(const struct lu_env *env,
struct cmm_device *cmm)
{
/* get the max mdsize and cookiesize from lower layer */
rc = cmm_maxsize_get(env, &cmm->cmm_md_dev, &max_mdsize,
- &max_cookiesize);
+ &max_cookiesize);
if (rc)
RETURN(rc);
- spin_lock(&cmm->cmm_tgt_guard);
- list_for_each_entry_safe(mc, tmp, &cmm->cmm_targets,
- mc_linkage) {
+ cfs_spin_lock(&cmm->cmm_tgt_guard);
+ cfs_list_for_each_entry_safe(mc, tmp, &cmm->cmm_targets,
+ mc_linkage) {
cmm_mdc_init_ea_size(env, mc, max_mdsize, max_cookiesize);
}
- spin_unlock(&cmm->cmm_tgt_guard);
+ cfs_spin_unlock(&cmm->cmm_tgt_guard);
RETURN(rc);
}
struct lu_device *ld;
struct lu_device *cmm_lu = cmm2lu_dev(cm);
mdsno_t mdc_num;
+ struct lu_site *site = cmm2lu_dev(cm)->ld_site;
int rc;
+#ifdef HAVE_QUOTA_SUPPORT
+ int first;
+#endif
ENTRY;
/* find out that there is no such mdc */
RETURN(-EINVAL);
}
- spin_lock(&cm->cmm_tgt_guard);
- list_for_each_entry_safe(mc, tmp, &cm->cmm_targets,
- mc_linkage) {
+ cfs_spin_lock(&cm->cmm_tgt_guard);
+ cfs_list_for_each_entry_safe(mc, tmp, &cm->cmm_targets,
+ mc_linkage) {
if (mc->mc_num == mdc_num) {
- spin_unlock(&cm->cmm_tgt_guard);
+ cfs_spin_unlock(&cm->cmm_tgt_guard);
RETURN(-EEXIST);
}
}
- spin_unlock(&cm->cmm_tgt_guard);
+ cfs_spin_unlock(&cm->cmm_tgt_guard);
ld = ldt->ldt_ops->ldto_device_alloc(env, ldt, cfg);
if (IS_ERR(ld))
RETURN(PTR_ERR(ld));
- ld->ld_site = cmm2lu_dev(cm)->ld_site;
+ ld->ld_site = site;
rc = ldt->ldt_ops->ldto_device_init(env, ld, NULL, NULL);
if (rc) {
RETURN(rc);
}
- spin_lock(&cm->cmm_tgt_guard);
- list_for_each_entry_safe(mc, tmp, &cm->cmm_targets,
- mc_linkage) {
+ cfs_spin_lock(&cm->cmm_tgt_guard);
+ cfs_list_for_each_entry_safe(mc, tmp, &cm->cmm_targets,
+ mc_linkage) {
if (mc->mc_num == mdc_num) {
- spin_unlock(&cm->cmm_tgt_guard);
+ cfs_spin_unlock(&cm->cmm_tgt_guard);
ldt->ldt_ops->ldto_device_fini(env, ld);
ldt->ldt_ops->ldto_device_free(env, ld);
RETURN(-EEXIST);
}
}
mc = lu2mdc_dev(ld);
- list_add_tail(&mc->mc_linkage, &cm->cmm_targets);
+ cfs_list_add_tail(&mc->mc_linkage, &cm->cmm_targets);
cm->cmm_tgt_count++;
- spin_unlock(&cm->cmm_tgt_guard);
+#ifdef HAVE_QUOTA_SUPPORT
+ first = cm->cmm_tgt_count;
+#endif
+ cfs_spin_unlock(&cm->cmm_tgt_guard);
lu_device_get(cmm_lu);
lu_ref_add(&cmm_lu->ld_reference, "mdc-child", ld);
target.ft_exp = mc->mc_desc.cl_exp;
fld_client_add_target(cm->cmm_fld, &target);
+ if (mc->mc_num == 0) {
+ /* this is mdt0 -> mc export, fld lookup need this export
+ to forward fld lookup request. */
+ LASSERT(!lu_site2md(site)->ms_server_fld->lsf_control_exp);
+ lu_site2md(site)->ms_server_fld->lsf_control_exp =
+ mc->mc_desc.cl_exp;
+ }
+#ifdef HAVE_QUOTA_SUPPORT
+ /* XXX: Disable quota for CMD case temporary. */
+ if (first == 1) {
+ CWARN("Disable quota for CMD case temporary!\n");
+ cmm_child_ops(cm)->mdo_quota.mqo_off(env, cm->cmm_child, UGQUOTA);
+ }
+#endif
/* Set max md size for the mdc. */
rc = cmm_post_init_mdc(env, cm);
RETURN(rc);
fld_client_del_target(cm->cmm_fld, cm->cmm_local_num);
/* Finish all mdc devices. */
- spin_lock(&cm->cmm_tgt_guard);
- list_for_each_entry_safe(mc, tmp, &cm->cmm_targets, mc_linkage) {
+ cfs_spin_lock(&cm->cmm_tgt_guard);
+ cfs_list_for_each_entry_safe(mc, tmp, &cm->cmm_targets, mc_linkage) {
struct lu_device *ld_m = mdc2lu_dev(mc);
fld_client_del_target(cm->cmm_fld, mc->mc_num);
ld_m->ld_ops->ldo_process_config(env, ld_m, cfg);
}
- spin_unlock(&cm->cmm_tgt_guard);
+ cfs_spin_unlock(&cm->cmm_tgt_guard);
/* remove upcall device*/
md_upcall_fini(&cm->cmm_md_dev);
struct lu_site *ls = cmm2lu_dev(m)->ld_site;
struct lu_fld_target target;
- target.ft_srv = ls->ls_server_fld;
+ target.ft_srv = lu_site2md(ls)->ms_server_fld;
target.ft_idx = m->cmm_local_num;
target.ft_exp = NULL;
RETURN(rc);
}
+static int cmm_prepare(const struct lu_env *env,
+ struct lu_device *pdev,
+ struct lu_device *dev)
+{
+ struct cmm_device *cmm = lu2cmm_dev(dev);
+ struct lu_device *next = md2lu_dev(cmm->cmm_child);
+ int rc;
+
+ ENTRY;
+ rc = next->ld_ops->ldo_prepare(env, dev, next);
+ RETURN(rc);
+}
+
static const struct lu_device_operations cmm_lu_ops = {
- .ldo_object_alloc = cmm_object_alloc,
+ .ldo_object_alloc = cmm_object_alloc,
.ldo_process_config = cmm_process_config,
- .ldo_recovery_complete = cmm_recovery_complete
+ .ldo_recovery_complete = cmm_recovery_complete,
+ .ldo_prepare = cmm_prepare,
};
/* --- lu_device_type operations --- */
int cmm_upcall(const struct lu_env *env, struct md_device *md,
- enum md_upcall_event ev)
+ enum md_upcall_event ev, void *data)
{
int rc;
ENTRY;
CERROR("can not init md size %d\n", rc);
/* fall through */
default:
- rc = md_do_upcall(env, md, ev);
+ rc = md_do_upcall(env, md, ev, data);
}
RETURN(rc);
}
ENTRY;
LASSERT(m->cmm_tgt_count == 0);
- LASSERT(list_empty(&m->cmm_targets));
+ LASSERT(cfs_list_empty(&m->cmm_targets));
if (m->cmm_fld != NULL) {
OBD_FREE_PTR(m->cmm_fld);
m->cmm_fld = NULL;
if (!m->cmm_fld) {
cmm_device_free(env, l);
l = ERR_PTR(-ENOMEM);
- }
+ }
}
RETURN(l);
}
/* type constructor/destructor: cmm_type_init/cmm_type_fini */
LU_TYPE_INIT_FINI(cmm, &cmm_thread_key);
+/*
+ * Kludge code : it should be moved mdc_device.c if mdc_(mds)_device
+ * is really stacked.
+ */
+static int __cmm_type_init(struct lu_device_type *t)
+{
+ int rc;
+ rc = lu_device_type_init(&mdc_device_type);
+ if (rc == 0) {
+ rc = cmm_type_init(t);
+ if (rc)
+ lu_device_type_fini(&mdc_device_type);
+ }
+ return rc;
+}
+
+static void __cmm_type_fini(struct lu_device_type *t)
+{
+ lu_device_type_fini(&mdc_device_type);
+ cmm_type_fini(t);
+}
+
+static void __cmm_type_start(struct lu_device_type *t)
+{
+ mdc_device_type.ldt_ops->ldto_start(&mdc_device_type);
+ cmm_type_start(t);
+}
+
+static void __cmm_type_stop(struct lu_device_type *t)
+{
+ mdc_device_type.ldt_ops->ldto_stop(&mdc_device_type);
+ cmm_type_stop(t);
+}
+
static int cmm_device_init(const struct lu_env *env, struct lu_device *d,
const char *name, struct lu_device *next)
{
int err = 0;
ENTRY;
- spin_lock_init(&m->cmm_tgt_guard);
+ cfs_spin_lock_init(&m->cmm_tgt_guard);
CFS_INIT_LIST_HEAD(&m->cmm_targets);
m->cmm_tgt_count = 0;
m->cmm_child = lu2md_dev(next);
/* Assign site's fld client ref, needed for asserts in osd. */
ls = cmm2lu_dev(m)->ld_site;
- ls->ls_client_fld = m->cmm_fld;
+ lu_site2md(ls)->ms_client_fld = m->cmm_fld;
err = cmm_procfs_init(m, name);
-
+
RETURN(err);
}
static struct lu_device *cmm_device_fini(const struct lu_env *env,
struct lu_device *ld)
{
- struct cmm_device *cm = lu2cmm_dev(ld);
+ struct cmm_device *cm = lu2cmm_dev(ld);
struct mdc_device *mc, *tmp;
struct lu_site *ls;
ENTRY;
/* Finish all mdc devices */
- spin_lock(&cm->cmm_tgt_guard);
- list_for_each_entry_safe(mc, tmp, &cm->cmm_targets, mc_linkage) {
+ cfs_spin_lock(&cm->cmm_tgt_guard);
+ cfs_list_for_each_entry_safe(mc, tmp, &cm->cmm_targets, mc_linkage) {
struct lu_device *ld_m = mdc2lu_dev(mc);
+ struct lu_device *ld_c = cmm2lu_dev(cm);
- list_del_init(&mc->mc_linkage);
- lu_device_put(cmm2lu_dev(cm));
+ cfs_list_del_init(&mc->mc_linkage);
+ lu_ref_del(&ld_c->ld_reference, "mdc-child", ld_m);
+ lu_device_put(ld_c);
ld_m->ld_type->ldt_ops->ldto_device_fini(env, ld_m);
ld_m->ld_type->ldt_ops->ldto_device_free(env, ld_m);
cm->cmm_tgt_count--;
}
- spin_unlock(&cm->cmm_tgt_guard);
+ cfs_spin_unlock(&cm->cmm_tgt_guard);
fld_client_fini(cm->cmm_fld);
ls = cmm2lu_dev(cm)->ld_site;
- ls->ls_client_fld = NULL;
+ lu_site2md(ls)->ms_client_fld = NULL;
cmm_procfs_fini(cm);
RETURN (md2lu_dev(cm->cmm_child));
}
static struct lu_device_type_operations cmm_device_type_ops = {
- .ldto_init = cmm_type_init,
- .ldto_fini = cmm_type_fini,
+ .ldto_init = __cmm_type_init,
+ .ldto_fini = __cmm_type_fini,
- .ldto_start = cmm_type_start,
- .ldto_stop = cmm_type_stop,
+ .ldto_start = __cmm_type_start,
+ .ldto_stop = __cmm_type_stop,
.ldto_device_alloc = cmm_device_alloc,
.ldto_device_free = cmm_device_free,
lvars->module_vars = lprocfs_cmm_module_vars;
lvars->obd_vars = lprocfs_cmm_obd_vars;
}
+/** @} */
static int __init cmm_mod_init(void)
{