static int mdd_init0(const struct lu_env *env, struct mdd_device *mdd,
struct lu_device_type *t, struct lustre_cfg *lcfg)
{
int rc;
ENTRY;
mdd->mdd_md_dev.md_lu_dev.ld_ops = &mdd_lu_ops;
mdd->mdd_md_dev.md_ops = &mdd_ops;
rc = mdd_connect_to_next(env, mdd, lustre_cfg_string(lcfg, 3));
if (rc)
RETURN(rc);
mdd->mdd_atime_diff = MAX_ATIME_DIFF;
/* sync permission changes */
mdd->mdd_sync_permission = 1;
dt_conf_get(env, mdd->mdd_child, &mdd->mdd_dt_conf);
/* we are using service name but not mdd obd name
* for compatibility reasons.
* It is passed from MDT in lustre_cfg[2] buffer */
rc = mdd_procfs_init(mdd, lustre_cfg_string(lcfg, 2));
if (rc < 0)
obd_disconnect(mdd->mdd_child_exp);
RETURN(rc);
}
static struct lu_device *osc_device_alloc(const struct lu_env *env,
struct lu_device_type *t,
struct lustre_cfg *cfg)
{
struct lu_device *d;
struct osc_device *od;
struct obd_device *obd;
int rc;
od = kzalloc(sizeof(*od), GFP_NOFS);
if (!od)
return ERR_PTR(-ENOMEM);
cl_device_init(&od->od_cl, t);
d = osc2lu_dev(od);
d->ld_ops = &osc_lu_ops;
/* Setup OSC OBD */
obd = class_name2obd(lustre_cfg_string(cfg, 0));
LASSERT(obd);
rc = osc_setup(obd, cfg);
if (rc) {
osc_device_free(env, d);
return ERR_PTR(rc);
}
od->od_exp = obd->obd_self_export;
return d;
}
static struct lu_device *osc_device_alloc(const struct lu_env *env,
struct lu_device_type *t,
struct lustre_cfg *cfg)
{
struct lu_device *d;
struct osc_device *od;
struct obd_device *obd;
int rc;
OBD_ALLOC_PTR(od);
if (od == NULL)
RETURN(ERR_PTR(-ENOMEM));
cl_device_init(&od->od_cl, t);
d = osc2lu_dev(od);
d->ld_ops = &osc_lu_ops;
od->od_cl.cd_ops = &osc_cl_ops;
/* Setup OSC OBD */
obd = class_name2obd(lustre_cfg_string(cfg, 0));
LASSERT(obd != NULL);
rc = osc_setup(obd, cfg);
if (rc) {
osc_device_free(env, d);
RETURN(ERR_PTR(rc));
}
od->od_exp = obd->obd_self_export;
RETURN(d);
}
static struct lu_device *lov_device_alloc(const struct lu_env *env,
struct lu_device_type *t,
struct lustre_cfg *cfg)
{
struct lu_device *d;
struct lov_device *ld;
struct obd_device *obd;
int rc;
ld = kzalloc(sizeof(*ld), GFP_NOFS);
if (!ld)
return ERR_PTR(-ENOMEM);
cl_device_init(&ld->ld_cl, t);
d = lov2lu_dev(ld);
d->ld_ops = &lov_lu_ops;
ld->ld_cl.cd_ops = &lov_cl_ops;
mutex_init(&ld->ld_mutex);
lockdep_set_class(&ld->ld_mutex, &cl_lov_device_mutex_class);
/* setup the LOV OBD */
obd = class_name2obd(lustre_cfg_string(cfg, 0));
LASSERT(obd != NULL);
rc = lov_setup(obd, cfg);
if (rc) {
lov_device_free(env, d);
return ERR_PTR(rc);
}
ld->ld_lov = &obd->u.lov;
return d;
}
/*
* Connect a quota master to the backend OSD device.
*
* \param env - is the environment passed by the caller
* \param qmt - is the quota master target to be connected
* \param cfg - is the configuration log record from which we need to extract
* the service name of the backend OSD device to connect to.
*
* \retval - 0 on success, appropriate error on failure
*/
static int qmt_connect_to_osd(const struct lu_env *env, struct qmt_device *qmt,
struct lustre_cfg *cfg)
{
struct obd_connect_data *data = NULL;
struct obd_device *obd;
struct lu_device *ld = qmt2lu_dev(qmt);
int rc;
ENTRY;
LASSERT(qmt->qmt_child_exp == NULL);
OBD_ALLOC_PTR(data);
if (data == NULL)
GOTO(out, rc = -ENOMEM);
/* look-up OBD device associated with the backend OSD device.
* The MDT is kind enough to pass the OBD name in QMT configuration */
obd = class_name2obd(lustre_cfg_string(cfg, 3));
if (obd == NULL) {
CERROR("%s: can't locate backend osd device: %s\n",
qmt->qmt_svname, lustre_cfg_string(cfg, 3));
GOTO(out, rc = -ENOTCONN);
}
data->ocd_connect_flags = OBD_CONNECT_VERSION;
data->ocd_version = LUSTRE_VERSION_CODE;
/* connect to OSD device */
rc = obd_connect(NULL, &qmt->qmt_child_exp, obd, &obd->obd_uuid, data,
NULL);
if (rc) {
CERROR("%s: cannot connect to osd dev %s (%d)\n",
qmt->qmt_svname, obd->obd_name, rc);
GOTO(out, rc);
}
/* initialize site (although it isn't used anywhere) and lu_device
* pointer to next device */
qmt->qmt_child = lu2dt_dev(qmt->qmt_child_exp->exp_obd->obd_lu_dev);
ld->ld_site = qmt->qmt_child_exp->exp_obd->obd_lu_dev->ld_site;
EXIT;
out:
if (data)
OBD_FREE_PTR(data);
return rc;
}
static int llog_test_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
struct lprocfs_static_vars lvars;
struct obd_device *tgt;
int rc;
ENTRY;
if (lcfg->lcfg_bufcount < 2) {
CERROR("requires a TARGET OBD name\n");
RETURN(-EINVAL);
}
if (lcfg->lcfg_buflens[1] < 1) {
CERROR("requires a TARGET OBD name\n");
RETURN(-EINVAL);
}
/* disk obd */
tgt = class_name2obd(lustre_cfg_string(lcfg, 1));
if (!tgt || !tgt->obd_attached || !tgt->obd_set_up) {
CERROR("target device not attached or not set up (%s)\n",
lustre_cfg_string(lcfg, 1));
RETURN(-EINVAL);
}
rc = obd_llog_init(obd, NULL, tgt, NULL);
if (rc)
RETURN(rc);
llog_test_rand = cfs_rand();
rc = llog_run_tests(obd);
if (rc)
llog_test_cleanup(obd);
lprocfs_llog_test_init_vars(&lvars);
lprocfs_obd_setup(obd, lvars.obd_vars);
RETURN(rc);
}
static void print_setup_cfg(struct lustre_cfg *lcfg)
{
struct lov_desc *desc;
if ((lcfg->lcfg_bufcount == 2) &&
(lcfg->lcfg_buflens[1] == sizeof(*desc))) {
printf("lov_setup ");
printf("0:%s ", lustre_cfg_string(lcfg, 0));
printf("1:(struct lov_desc)\n");
desc = (struct lov_desc*)(lustre_cfg_string(lcfg, 1));
printf("\t\tuuid=%s ", (char*)desc->ld_uuid.uuid);
printf("stripe:cnt=%u ", desc->ld_default_stripe_count);
printf("size="LPU64" ", desc->ld_default_stripe_size);
printf("offset="LPU64" ", desc->ld_default_stripe_offset);
printf("pattern=%#x", desc->ld_pattern);
} else {
printf("setup ");
print_1_cfg(lcfg);
}
return;
}
static int mds_lov_presetup (struct mds_obd *mds, struct lustre_cfg *lcfg)
{
int rc = 0;
ENTRY;
if (lcfg->lcfg_bufcount >= 4 && LUSTRE_CFG_BUFLEN(lcfg, 3) > 0) {
class_uuid_t uuid;
ll_generate_random_uuid(uuid);
class_uuid_unparse(uuid, &mds->mds_lov_uuid);
OBD_ALLOC(mds->mds_profile, LUSTRE_CFG_BUFLEN(lcfg, 3));
if (mds->mds_profile == NULL)
RETURN(-ENOMEM);
strncpy(mds->mds_profile, lustre_cfg_string(lcfg, 3),
LUSTRE_CFG_BUFLEN(lcfg, 3));
}
RETURN(rc);
}
static int llog_test_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
struct obd_device *tgt;
struct llog_ctxt *ctxt;
struct dt_object *o;
struct lu_env env;
struct lu_context test_session;
int rc;
if (lcfg->lcfg_bufcount < 2) {
CERROR("requires a TARGET OBD name\n");
return -EINVAL;
}
if (lcfg->lcfg_buflens[1] < 1) {
CERROR("requires a TARGET OBD name\n");
return -EINVAL;
}
/* disk obd */
tgt = class_name2obd(lustre_cfg_string(lcfg, 1));
if (!tgt || !tgt->obd_attached || !tgt->obd_set_up) {
CERROR("target device not attached or not set up (%s)\n",
lustre_cfg_string(lcfg, 1));
return -EINVAL;
}
rc = lu_env_init(&env, LCT_LOCAL | LCT_MG_THREAD);
if (rc)
return rc;
rc = lu_context_init(&test_session, LCT_SESSION);
if (rc)
GOTO(cleanup_env, rc);
test_session.lc_thread = (struct ptlrpc_thread *)current;
lu_context_enter(&test_session);
env.le_ses = &test_session;
CWARN("Setup llog-test device over %s device\n",
lustre_cfg_string(lcfg, 1));
OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt);
obd->obd_lvfs_ctxt.dt = lu2dt_dev(tgt->obd_lu_dev);
rc = llog_setup(&env, tgt, &tgt->obd_olg, LLOG_TEST_ORIG_CTXT, tgt,
&llog_osd_ops);
if (rc)
GOTO(cleanup_session, rc);
/* use MGS llog dir for tests */
ctxt = llog_get_context(tgt, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt);
o = ctxt->loc_dir;
llog_ctxt_put(ctxt);
ctxt = llog_get_context(tgt, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
ctxt->loc_dir = o;
llog_ctxt_put(ctxt);
llog_test_rand = cfs_rand();
rc = llog_run_tests(&env, tgt);
if (rc)
llog_test_cleanup(obd);
cleanup_session:
lu_context_exit(&test_session);
lu_context_fini(&test_session);
cleanup_env:
lu_env_fini(&env);
return rc;
}
/*
* Initialize quota master target device. This includers connecting to
* the backend OSD device, initializing the pool configuration and creating the
* root procfs directory dedicated to this quota target.
* The rest of the initialization is done when the stack is fully configured
* (i.e. when ->ldo_start is called across the stack).
*
* This function is called on MDT0 setup.
*
* \param env - is the environment passed by the caller
* \param qmt - is the quota master target to be initialized
* \param ldt - is the device type structure associated with the qmt device
* \param cfg - is the configuration record used to configure the qmt device
*
* \retval - 0 on success, appropriate error on failure
*/
static int qmt_device_init0(const struct lu_env *env, struct qmt_device *qmt,
struct lu_device_type *ldt, struct lustre_cfg *cfg)
{
struct lu_device *ld = qmt2lu_dev(qmt);
struct obd_device *obd, *mdt_obd;
struct obd_type *type;
int rc;
ENTRY;
/* record who i am, it might be useful ... */
strncpy(qmt->qmt_svname, lustre_cfg_string(cfg, 0),
sizeof(qmt->qmt_svname) - 1);
/* look-up the obd_device associated with the qmt */
obd = class_name2obd(qmt->qmt_svname);
if (obd == NULL)
RETURN(-ENOENT);
/* reference each other */
obd->obd_lu_dev = ld;
ld->ld_obd = obd;
/* look-up the parent MDT to steal its ldlm namespace ... */
mdt_obd = class_name2obd(lustre_cfg_string(cfg, 2));
if (mdt_obd == NULL)
RETURN(-ENOENT);
/* borrow MDT namespace. kind of a hack until we have our own namespace
* & service threads */
LASSERT(mdt_obd->obd_namespace != NULL);
obd->obd_namespace = mdt_obd->obd_namespace;
qmt->qmt_ns = obd->obd_namespace;
/* connect to backend osd device */
rc = qmt_connect_to_osd(env, qmt, cfg);
if (rc)
GOTO(out, rc);
/* set up and start rebalance thread */
thread_set_flags(&qmt->qmt_reba_thread, SVC_STOPPED);
init_waitqueue_head(&qmt->qmt_reba_thread.t_ctl_waitq);
CFS_INIT_LIST_HEAD(&qmt->qmt_reba_list);
spin_lock_init(&qmt->qmt_reba_lock);
rc = qmt_start_reba_thread(qmt);
if (rc) {
CERROR("%s: failed to start rebalance thread (%d)\n",
qmt->qmt_svname, rc);
GOTO(out, rc);
}
/* at the moment there is no linkage between lu_type and obd_type, so
* we lookup obd_type this way */
type = class_search_type(LUSTRE_QMT_NAME);
LASSERT(type != NULL);
/* register proc directory associated with this qmt */
qmt->qmt_proc = lprocfs_register(qmt->qmt_svname, type->typ_procroot,
NULL, NULL);
if (IS_ERR(qmt->qmt_proc)) {
rc = PTR_ERR(qmt->qmt_proc);
CERROR("%s: failed to create qmt proc entry (%d)\n",
qmt->qmt_svname, rc);
GOTO(out, rc);
}
/* initialize pool configuration */
rc = qmt_pool_init(env, qmt);
if (rc)
GOTO(out, rc);
EXIT;
out:
if (rc)
qmt_device_fini(env, ld);
return rc;
}
/*mds still need lov setup here*/
static int mds_cmd_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
struct mds_obd *mds = &obd->u.mds;
struct lvfs_run_ctxt saved;
const char *dev;
struct vfsmount *mnt;
struct lustre_sb_info *lsi;
struct lustre_mount_info *lmi;
struct dentry *dentry;
int rc = 0;
ENTRY;
CDEBUG(D_INFO, "obd %s setup \n", obd->obd_name);
if (strncmp(obd->obd_name, MDD_OBD_NAME, strlen(MDD_OBD_NAME)))
RETURN(0);
if (lcfg->lcfg_bufcount < 5) {
CERROR("invalid arg for setup %s\n", MDD_OBD_NAME);
RETURN(-EINVAL);
}
dev = lustre_cfg_string(lcfg, 4);
lmi = server_get_mount(dev);
LASSERT(lmi != NULL);
lsi = s2lsi(lmi->lmi_sb);
mnt = lmi->lmi_mnt;
/* FIXME: MDD LOV initialize objects.
* we need only lmi here but not get mount
* OSD did mount already, so put mount back
*/
cfs_atomic_dec(&lsi->lsi_mounts);
mntput(mnt);
cfs_init_rwsem(&mds->mds_notify_lock);
obd->obd_fsops = fsfilt_get_ops(MT_STR(lsi->lsi_ldd));
mds_init_ctxt(obd, mnt);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
dentry = simple_mkdir(current->fs->pwd, mnt, "OBJECTS", 0777, 1);
if (IS_ERR(dentry)) {
rc = PTR_ERR(dentry);
CERROR("cannot create OBJECTS directory: rc = %d\n", rc);
GOTO(err_putfs, rc);
}
mds->mds_objects_dir = dentry;
dentry = ll_lookup_one_len("__iopen__", current->fs->pwd,
strlen("__iopen__"));
if (IS_ERR(dentry)) {
rc = PTR_ERR(dentry);
CERROR("cannot lookup __iopen__ directory: rc = %d\n", rc);
GOTO(err_objects, rc);
}
mds->mds_fid_de = dentry;
if (!dentry->d_inode || is_bad_inode(dentry->d_inode)) {
rc = -ENOENT;
CERROR("__iopen__ directory has no inode? rc = %d\n", rc);
GOTO(err_fid, rc);
}
rc = mds_lov_init_objids(obd);
if (rc != 0) {
CERROR("cannot init lov objid rc = %d\n", rc);
GOTO(err_fid, rc );
}
rc = mds_lov_presetup(mds, lcfg);
if (rc < 0)
GOTO(err_objects, rc);
/* Don't wait for mds_postrecov trying to clear orphans */
obd->obd_async_recov = 1;
rc = mds_postsetup(obd);
/* Bug 11557 - allow async abort_recov start
FIXME can remove most of this obd_async_recov plumbing
obd->obd_async_recov = 0;
*/
if (rc)
GOTO(err_objects, rc);
err_pop:
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
RETURN(rc);
err_fid:
dput(mds->mds_fid_de);
err_objects:
dput(mds->mds_objects_dir);
err_putfs:
fsfilt_put_ops(obd->obd_fsops);
goto err_pop;
}
static int mgs_iocontrol_pool(struct obd_device *obd,
struct obd_ioctl_data *data)
{
int rc;
struct lustre_cfg *lcfg = NULL;
struct llog_rec_hdr rec;
char *fsname = NULL;
char *poolname = NULL;
ENTRY;
OBD_ALLOC(fsname, MTI_NAME_MAXLEN);
if (fsname == NULL)
RETURN(-ENOMEM);
OBD_ALLOC(poolname, LOV_MAXPOOLNAME + 1);
if (poolname == NULL) {
rc = -ENOMEM;
GOTO(out_pool, rc);
}
rec.lrh_len = llog_data_len(data->ioc_plen1);
if (data->ioc_type == LUSTRE_CFG_TYPE) {
rec.lrh_type = OBD_CFG_REC;
} else {
CERROR("unknown cfg record type:%d \n", data->ioc_type);
rc = -EINVAL;
GOTO(out_pool, rc);
}
if (data->ioc_plen1 > CFS_PAGE_SIZE) {
rc = -E2BIG;
GOTO(out_pool, rc);
}
OBD_ALLOC(lcfg, data->ioc_plen1);
if (lcfg == NULL)
GOTO(out_pool, rc = -ENOMEM);
if (cfs_copy_from_user(lcfg, data->ioc_pbuf1, data->ioc_plen1))
GOTO(out_pool, rc = -EFAULT);
if (lcfg->lcfg_bufcount < 2) {
GOTO(out_pool, rc = -EFAULT);
}
/* first arg is always <fsname>.<poolname> */
mgs_extract_fs_pool(lustre_cfg_string(lcfg, 1), fsname,
poolname);
switch (lcfg->lcfg_command) {
case LCFG_POOL_NEW: {
if (lcfg->lcfg_bufcount != 2)
RETURN(-EINVAL);
rc = mgs_pool_cmd(obd, LCFG_POOL_NEW, fsname,
poolname, NULL);
break;
}
case LCFG_POOL_ADD: {
if (lcfg->lcfg_bufcount != 3)
RETURN(-EINVAL);
rc = mgs_pool_cmd(obd, LCFG_POOL_ADD, fsname, poolname,
lustre_cfg_string(lcfg, 2));
break;
}
case LCFG_POOL_REM: {
if (lcfg->lcfg_bufcount != 3)
RETURN(-EINVAL);
rc = mgs_pool_cmd(obd, LCFG_POOL_REM, fsname, poolname,
lustre_cfg_string(lcfg, 2));
break;
}
case LCFG_POOL_DEL: {
if (lcfg->lcfg_bufcount != 2)
RETURN(-EINVAL);
rc = mgs_pool_cmd(obd, LCFG_POOL_DEL, fsname,
poolname, NULL);
break;
}
default: {
rc = -EINVAL;
GOTO(out_pool, rc);
}
}
if (rc) {
CERROR("OBD_IOC_POOL err %d, cmd %X for pool %s.%s\n",
rc, lcfg->lcfg_command, fsname, poolname);
GOTO(out_pool, rc);
}
out_pool:
if (lcfg != NULL)
OBD_FREE(lcfg, data->ioc_plen1);
if (fsname != NULL)
OBD_FREE(fsname, MTI_NAME_MAXLEN);
if (poolname != NULL)
OBD_FREE(poolname, LOV_MAXPOOLNAME + 1);
RETURN(rc);
}
