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); }